package com.thinkgem.jeesite.modules.export.service;

import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.ui.Model;

import com.thinkgem.jeesite.common.mapper.JsonMapper;
import com.thinkgem.jeesite.common.service.CrudService;
import com.thinkgem.jeesite.common.utils.DateUtils;
import com.thinkgem.jeesite.common.utils.IdGen;
import com.thinkgem.jeesite.common.utils.StringUtils;
import com.thinkgem.jeesite.modules.export.dao.ExpRoutinevacc6_1Dao;
import com.thinkgem.jeesite.modules.export.entity.ExpRoutinevacc6_1;
import com.thinkgem.jeesite.modules.export.entity.ExportChildhelp;
import com.thinkgem.jeesite.modules.sys.entity.Office;
import com.thinkgem.jeesite.modules.sys.entity.User;
import com.thinkgem.jeesite.modules.sys.utils.CollectionUtils;
import com.thinkgem.jeesite.modules.sys.utils.TimeUtils;
import com.thinkgem.jeesite.modules.sys.utils.UserUtils;

/**
 * 常规报表6-1 Service
 * 
 * @author Jack
 * @date 2017年10月13日 下午2:35:56
 */
@Service
public class ExpRoutinevacc6_1Service extends CrudService<ExpRoutinevacc6_1Dao, ExpRoutinevacc6_1> {
	@Autowired
	ExpRoutinevacc6_1Dao dao;
	
	List<ExpRoutinevacc6_1> ff = new ArrayList<ExpRoutinevacc6_1>();
	private HashMap<String, String> Vacc_in_Map = new HashMap<String, String>(); // 是否是需要进行统计疫苗信息 Map 根据模型ID
	
	// 应种本地
	public Map<String, Object> Y_BD_BCG_Map = new HashMap<String, Object>(); // 本地卡介应种

	public HashMap<Object, Object> Y_BD_JSS_Map = new HashMap<Object, Object>(); // 首针乙肝1针及时数
	private HashMap<String, String> Y_BD_HepB1_Map = new HashMap<String, String>(); // 本地乙肝1针应种
	private HashMap<String, String> Y_BD_HepB2_Map = new HashMap<String, String>(); // 本地乙肝2针应种
	private HashMap<String, String> Y_BD_HepB3_Map = new HashMap<String, String>(); // 本地乙肝3针应种

	private HashMap<String, String> Y_BD_PV1_Map = new HashMap<String, String>(); // 本 地脊灰1 应种2月
	private HashMap<String, String> Y_BD_PV2_Map = new HashMap<String, String>(); // 本 地脊灰2 应种3月
	private HashMap<String, String> Y_BD_PV3_Map = new HashMap<String, String>(); // 本 地脊灰3 应种4月
	private HashMap<String, String> Y_BD_PV4_Map = new HashMap<String, String>(); // 本 地脊灰4 应种4周

	private HashMap<String, String> Y_BD_DTP1_Map = new HashMap<String, String>(); // 本 地百白破1 应种3月
	private HashMap<String, String> Y_BD_DTP2_Map = new HashMap<String, String>(); // 本 地百白破2 应种4月
	private HashMap<String, String> Y_BD_DTP3_Map = new HashMap<String, String>(); // 本 地百白破3 应种5月
	private HashMap<String, String> Y_BD_DTP4_Map = new HashMap<String, String>(); // 本 地百白破4 应种18-24月

	private HashMap<String, Object> Y_BD_DT1_Map = new HashMap<String, Object>(); // 本 地白破1 应种 6周

	private HashMap<String, Object> Y_BD_MR1_Map = new HashMap<String, Object>(); // 本 地麻风1 应种 8月龄

	private HashMap<String, Object> Y_BD_MMR1_Map = new HashMap<String, Object>(); // 本 地麻腮风1 应种 18月龄

	private HashMap<String, String> Y_BD_JE_L1_Map = new HashMap<String, String>(); // 本 地乙脑减毒1 应种 8月龄
	private HashMap<String, String> Y_BD_JE_L2_Map = new HashMap<String, String>(); // 本 地乙脑减毒2 应种 24月龄

	private HashMap<String, String> Y_BD_JE_I1_Map = new HashMap<String, String>(); // 本 地乙脑灭活1 应种 8月龄
	private HashMap<String, String> Y_BD_JE_I2_Map = new HashMap<String, String>(); // 本 地乙脑灭活2 应种 8月龄
	private HashMap<String, String> Y_BD_JE_I3_Map = new HashMap<String, String>(); // 本 地乙脑灭活3 应种 24月龄
	private HashMap<String, String> Y_BD_JE_I4_Map = new HashMap<String, String>(); // 本 地乙脑灭活4 应种 72月龄

	private HashMap<String, String> Y_BD_MPSV_A1_Map = new HashMap<String, String>(); // 本 地A群流脑多糖 1 应种 6月
	private HashMap<String, String> Y_BD_MPSV_A2_Map = new HashMap<String, String>(); // 本 地A群流脑多糖 2 应种 9月

	private HashMap<String, String> Y_BD_MenA1_Map = new HashMap<String, String>(); // 本 地A+C群流脑结合1 应种 6月 模型ID=871
	private HashMap<String, String> Y_BD_MenA2_Map = new HashMap<String, String>(); // 本 地A+C群流脑结合 2 应种 7月 模型ID=872

	private HashMap<String, String> Y_BD_MenAC1_Map = new HashMap<String, String>(); // 本 地A+C群流脑多糖1 应种36月
	private HashMap<String, String> Y_BD_MenAC2_Map = new HashMap<String, String>(); // 本 地A+C群流脑多糖2 应种 72月

	private HashMap<String, Object> Y_BD_HepA_L1_Map = new HashMap<String, Object>(); // 本地甲肝减毒1针应种

	private HashMap<String, String> Y_BD_HepA_I1_Map = new HashMap<String, String>(); // 本地甲肝灭活1针应种
	private HashMap<String, String> Y_BD_HepA_I2_Map = new HashMap<String, String>(); // 本地甲肝灭活2针应种

	// 实种本地
	private HashMap<String, String> S_BD_BCG_Map = new HashMap<String, String>(); // 本地卡介应种

	private HashMap<String, String> S_BD_HepB1_Map = new HashMap<String, String>(); // 本地乙肝1针应种

	private HashMap<String, String> S_BD_HepB2_Map = new HashMap<String, String>(); // 本地乙肝2针应种

	private HashMap<String, String> S_BD_HepB3_Map = new HashMap<String, String>(); // 本地乙肝3针应种

	private HashMap<String, String> S_BD_PV1_Map = new HashMap<String, String>(); // 本 地脊灰1 应种2月
	private HashMap<String, String> S_BD_PV2_Map = new HashMap<String, String>(); // 本 地脊灰2 应种3月
	private HashMap<String, String> S_BD_PV3_Map = new HashMap<String, String>(); // 本 地脊灰3 应种4月
	private HashMap<String, String> S_BD_PV4_Map = new HashMap<String, String>(); // 本 地脊灰4 应种4周

	private HashMap<String, String> S_BD_DTP1_Map = new HashMap<String, String>(); // 本 地百白破1 应种3月
	private HashMap<String, String> S_BD_DTP2_Map = new HashMap<String, String>(); // 本 地百白破2 应种4月
	private HashMap<String, String> S_BD_DTP3_Map = new HashMap<String, String>(); // 本 地百白破3 应种5月
	private HashMap<String, String> S_BD_DTP4_Map = new HashMap<String, String>(); // 本 地百白破4 应种18-24月

	private HashMap<String, String> S_BD_DT1_Map = new HashMap<String, String>(); // 本 地白破1 应种 6周

	private HashMap<String, String> S_BD_MR1_Map = new HashMap<String, String>(); // 本 地麻风1 应种 8月龄

	private HashMap<String, String> S_BD_MMR1_Map = new HashMap<String, String>(); // 本 地麻腮风1 应种 18月龄

	private HashMap<String, String> S_BD_JE_L1_Map = new HashMap<String, String>(); // 本 地乙脑减毒1 应种 8月龄
	private HashMap<String, String> S_BD_JE_L2_Map = new HashMap<String, String>(); // 本 地乙脑减毒2 应种 24月龄

	private HashMap<String, String> S_BD_JE_I1_Map = new HashMap<String, String>(); // 本 地乙脑灭活1 应种 8月龄
	private HashMap<String, String> S_BD_JE_I2_Map = new HashMap<String, String>(); // 本 地乙脑灭活2 应种 8月龄
	private HashMap<String, String> S_BD_JE_I3_Map = new HashMap<String, String>(); // 本 地乙脑灭活3 应种 24月龄
	private HashMap<String, String> S_BD_JE_I4_Map = new HashMap<String, String>(); // 本 地乙脑灭活4 应种 72月龄

	private HashMap<String, String> S_BD_MPSV_A1_Map = new HashMap<String, String>(); // 本 地A群流脑多糖 1 应种 6月
	private HashMap<String, String> S_BD_MPSV_A2_Map = new HashMap<String, String>(); // 本 地A群流脑多糖 2 应种 9月

	private HashMap<String, String> S_BD_MenA1_Map = new HashMap<String, String>(); // 本 地A+C群流脑结合1 应种 6月 模型ID=871
	private HashMap<String, String> S_BD_MenA2_Map = new HashMap<String, String>(); // 本 地A+C群流脑结合 2 应种 7月 模型ID=872

	private HashMap<String, String> S_BD_MenAC1_Map = new HashMap<String, String>(); // 本 地A+C群流脑多糖1 应种36月
	private HashMap<String, String> S_BD_MenAC2_Map = new HashMap<String, String>(); // 本 地A+C群流脑多糖2 应种 72月

	private HashMap<String, String> S_BD_HepA_L1_Map = new HashMap<String, String>(); // 本地甲肝减毒1针应种

	private HashMap<String, String> S_BD_HepA_I1_Map = new HashMap<String, String>(); // 本地甲肝灭活1针应种
	private HashMap<String, String> S_BD_HepA_I2_Map = new HashMap<String, String>(); // 本地甲肝灭活2针应种
	
	
	
	
	//所有子节点应种总和
	public Integer Y_CHILDS_BCG = 0; // 本地卡介应种

	private Integer Y_CHILDS_JSS = 0; // 首针乙肝1针及时数
	private Integer Y_CHILDS_HepB1 = 0; // 本地乙肝1针应
	private Integer Y_CHILDS_HepB2 = 0; // 本地乙肝2针应
	private Integer Y_CHILDS_HepB3 = 0; // 本地乙肝3针应

	private Integer Y_CHILDS_PV1 = 0; // 本 地脊灰1 应种2
	private Integer Y_CHILDS_PV2 = 0; // 本 地脊灰2 应种3
	private Integer Y_CHILDS_PV3 = 0; // 本 地脊灰3 应种4
	private Integer Y_CHILDS_PV4 = 0; // 本 地脊灰4 应种4

	private Integer Y_CHILDS_DTP1 = 0; // 本 地百白破1 应种3
	private Integer Y_CHILDS_DTP2 = 0; // 本 地百白破2 应种4
	private Integer Y_CHILDS_DTP3 = 0; // 本 地百白破3 应种5
	private Integer Y_CHILDS_DTP4 = 0; // 本 地百白破4 应种18-24月

	private Integer Y_CHILDS_DT1 = 0; // 本 地白破1 应种 6周
                                    
	private Integer Y_CHILDS_MR1 = 0; // 本 地麻风1 应种 8月龄
	private Integer Y_CHILDS_MR2 = 0; 
                                     
	private Integer Y_CHILDS_MMR1 = 0; // 本 地麻腮风1 应种 18月龄
	private Integer Y_CHILDS_MMR2 = 0; // 本 地麻腮风12应种
	
	private Integer Y_CHILDS_MM1 = 0; 
	private Integer Y_CHILDS_MM2 = 0; 
	
	private Integer Y_CHILDS_MV1 = 0; 
	private Integer Y_CHILDS_MV2 = 0; 
	
	private Integer Y_CHILDS_MENA1 = 0; 
	private Integer Y_CHILDS_MENA2 = 0; 
	
	private Integer Y_CHILDS_MENAC1 = 0; 
	private Integer Y_CHILDS_MENAC2 = 0; 
	
                                      
	private Integer Y_CHILDS_JE_L1 = 0; // 本 地乙脑减毒1 应种 8月龄
	private Integer Y_CHILDS_JE_L2 = 0; // 本 地乙脑减毒2 应种 24月龄

	private Integer Y_CHILDS_JE_I1 = 0; // 本 地乙脑灭活1 应种 8月
	private Integer Y_CHILDS_JE_I2 = 0; // 本 地乙脑灭活2 应种 8月
	private Integer Y_CHILDS_JE_I3 = 0; // 本 地乙脑灭活3 应种 24月
	private Integer Y_CHILDS_JE_I4 = 0; // 本 地乙脑灭活4 应种 72月

	private Integer Y_CHILDS_HepA_L1 = 0; // 本地甲肝减毒1针应种
                                    
	private Integer Y_CHILDS_HepA_I1 = 0; // 本地甲肝灭活1针应种
	private Integer Y_CHILDS_HepA_I2 = 0; // 本地甲肝灭活2针应种

	//所有子节点实种总和
	private Integer S_CHILDS_BCG = 0; // 本地卡介
	
	private Integer S_CHILDS_JSS = 0; // 首针乙肝1针及时数
	private Integer S_CHILDS_HepB1 = 0; // 本地乙肝1针应
	private Integer S_CHILDS_HepB2 = 0; // 本地乙肝2针应
	private Integer S_CHILDS_HepB3 = 0; // 本地乙肝3针应
                                
	private Integer S_CHILDS_PV1 = 0; // 本 地脊灰1
	private Integer S_CHILDS_PV2 = 0; // 本 地脊灰2
	private Integer S_CHILDS_PV3 = 0; // 本 地脊灰3
	private Integer S_CHILDS_PV4 = 0; // 本 地脊灰4
                                   
	private Integer S_CHILDS_DTP1 = 0; // 本 地百白破1
	private Integer S_CHILDS_DTP2 = 0; // 本 地百白破2
	private Integer S_CHILDS_DTP3 = 0; // 本 地百白破3
	private Integer S_CHILDS_DTP4 = 0; // 本 地百白破4
                                  
	private Integer S_CHILDS_DT1 = 0; // 本 地白破16周
                                
	private Integer S_CHILDS_MR1 = 0; // 本 地麻风1 8月龄
	private Integer S_CHILDS_MR2 = 0; 
                                      
	private Integer S_CHILDS_MMR1 = 0; // 本 地麻腮风1 18月龄
	private Integer S_CHILDS_MMR2 = 0; 
	
	private Integer S_CHILDS_MM1 = 0; 
	private Integer S_CHILDS_MM2 = 0; 
	
	private Integer S_CHILDS_MV1 = 0; 
	private Integer S_CHILDS_MV2 = 0; 
	
	private Integer S_CHILDS_MENA1 = 0; 
	private Integer S_CHILDS_MENA2 = 0; 
	
	private Integer S_CHILDS_MENAC1 = 0; 
	private Integer S_CHILDS_MENAC2 = 0; 
                                     
	private Integer S_CHILDS_JE_L1 = 0; // 本 地乙脑减毒1 8月龄
	private Integer S_CHILDS_JE_L2 = 0; // 本 地乙脑减毒2 24月龄
                                     
	private Integer S_CHILDS_JE_I1 = 0; // 本 地乙脑灭活1 8月
	private Integer S_CHILDS_JE_I2 = 0; // 本 地乙脑灭活2 8月
	private Integer S_CHILDS_JE_I3 = 0; // 本 地乙脑灭活3 24月
	private Integer S_CHILDS_JE_I4 = 0; // 本 地乙脑灭活4 72月
                                      
	private Integer S_CHILDS_HepA_L1 = 0; // 本地甲肝减毒1针
                                    
	private Integer S_CHILDS_HepA_I1 = 0; // 本地甲肝灭活1
	private Integer S_CHILDS_HepA_I2 = 0; // 本地甲肝灭活2
	
	//所有子节点接种率总和
	private String RE_CHILDS_BCG = "0"; // 本地卡介
	
	private String RE_CHILDS_JSS = "0"; // 首针乙肝1针及时数
	private String RE_CHILDS_HepB1 = "0"; // 本地乙肝1
	private String RE_CHILDS_HepB2 = "0"; // 本地乙肝2
	private String RE_CHILDS_HepB3 = "0"; // 本地乙肝3
                                
	private String RE_CHILDS_PV1 = "0"; // 本 地脊灰1
	private String RE_CHILDS_PV2 = "0"; // 本 地脊灰2
	private String RE_CHILDS_PV3 = "0"; // 本 地脊灰3
	private String RE_CHILDS_PV4 = "0"; // 本 地脊灰4
                                   
	private String RE_CHILDS_DTP1 = "0"; // 本 地百白破1
	private String RE_CHILDS_DTP2 = "0"; // 本 地百白破2
	private String RE_CHILDS_DTP3 = "0"; // 本 地百白破3
	private String RE_CHILDS_DTP4 = "0"; // 本 地百白破4 
                                  
	private String RE_CHILDS_DT1 = "0"; // 本 地白破1 6周
                                
	private String RE_CHILDS_MR1 = "0"; // 本 地麻风1 8月龄
	private String RE_CHILDS_MR2 = "0"; 
                                      
	private String RE_CHILDS_MMR1 = "0"; // 本 地麻腮风1 18月龄
	private String RE_CHILDS_MMR2 = "0"; 
	
	private String RE_CHILDS_MM1 = "0"; 
	private String RE_CHILDS_MM2 = "0"; 
	
	private String RE_CHILDS_MV1 = "0"; 
	private String RE_CHILDS_MV2 = "0"; 
	
	private String RE_CHILDS_MENA1 = "0"; 
	private String RE_CHILDS_MENA2 = "0"; 
	
	private String RE_CHILDS_MENAC1 = "0"; 
	private String RE_CHILDS_MENAC2 = "0"; 
                                     
	private String RE_CHILDS_JE_L1 = "0"; // 本 地乙脑减毒1 
	private String RE_CHILDS_JE_L2 = "0"; // 本 地乙脑减毒2 
                                     
	private String RE_CHILDS_JE_I1 = "0"; // 本 地乙脑灭活1 8月
	private String RE_CHILDS_JE_I2 = "0"; // 本 地乙脑灭活2 8月
	private String RE_CHILDS_JE_I3 = "0"; // 本 地乙脑灭活3 24月
	private String RE_CHILDS_JE_I4 = "0"; // 本 地乙脑灭活4 72月
                                      
	private String RE_CHILDS_HepA_L1 = "0"; // 本地甲肝减毒1针
                                    
	private String RE_CHILDS_HepA_I1 = "0"; // 本地甲肝灭活1针应
	private String RE_CHILDS_HepA_I2 = "0"; // 本地甲肝灭活2针应
	
	private String createDate =null;
	private Integer monthNum = null;
	
	public ExpRoutinevacc6_1Service() {
		
	}

	/**
	 * 计算上个月实种、应种、接种率
	 * @author Jack
	 * @date 2017年10月13日 上午9:33:43
	 */
public void getDataByMonth(String yearStr, String monthStr, String localCode) {
		
		//判断给定的localCode下的指定月份数据是否已经生成,若已经生成则不再生成计算该条件下的数据
		int dataNum = countDataByMonthAndLocalCode(yearStr+"-"+monthStr, localCode);
		if(dataNum > 0){
			return;
		}

		Vacc_in_Map.put("16", "流脑A"); // 流脑A模型Map
		Vacc_in_Map.put("87", "A群C群流脑结合"); // A群C群流脑结合模型Map
		Vacc_in_Map.put("01", "卡介"); // 卡介疫苗模型Map
		Vacc_in_Map.put("02", "乙肝"); // 乙肝疫苗模型Map
		Vacc_in_Map.put("03", "脊灰"); // 脊灰疫苗模型Map
		Vacc_in_Map.put("04", "百白破疫苗"); // 百白破疫苗模型Map
		Vacc_in_Map.put("06", "白破疫苗"); // 白破疫苗模型Map
		Vacc_in_Map.put("14", "麻风疫苗"); // 麻风疫苗模型Map
		Vacc_in_Map.put("12", "麻腮风疫苗"); // 麻腮风疫苗模型Map
		Vacc_in_Map.put("84", "乙脑减毒活疫苗"); // 乙脑减毒活疫苗模型Map
		Vacc_in_Map.put("87", "A+C群流脑结合疫苗"); // A+C群流脑结合疫苗模型Map
		Vacc_in_Map.put("17", "A+C群流脑多糖疫苗"); // A+C群流脑多糖疫苗模型Map
		Vacc_in_Map.put("82", "甲肝减毒活疫苗"); // 甲肝减毒活疫苗模型Map
		
		SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM");
		
		if(StringUtils.isNotBlank(yearStr) && StringUtils.isNotBlank(monthStr)){
			Calendar c = Calendar.getInstance();
			Integer nowYear = c.get(Calendar.YEAR);
			Integer nowMonth = c.get(Calendar.MONTH) + 1;
			Integer year = Integer.valueOf(yearStr);
			Integer month = Integer.valueOf(monthStr);
			if(nowYear.equals(year)){
				//获取数据在当年,只有月份差异
				monthNum = -(nowMonth - month);
				
				//初始化当前时间的上个月份数据
				c.setTime(new Date());
				c.add(Calendar.MONTH, monthNum);
				Date dd = c.getTime();
				createDate = sf.format(dd);
			}else{
				if(nowYear > year){
					//获取数据不在当年,需要按照年计算中间的间隔月
					monthNum = -((nowYear - year)*12 + nowMonth - month);
				}else{
					monthNum = (nowYear - year)*12 + nowMonth - month;
				}
				
				//初始化指定月份的数据
				c.setTime(new Date());
				c.add(Calendar.MONTH, monthNum);
				Date dd = c.getTime();
				createDate = sf.format(dd);
			}
			
		}else{
			//设置数据初始化月份为上个月
			Calendar c = Calendar.getInstance();
			c.setTime(new Date());
	        c.add(Calendar.MONTH, -1);
	        Date dd = c.getTime();
	        String createDate = sf.format(dd);
		}
		
		//设置officeStr 为本地站点编码
//		String officeStr = OfficeService.getFirstOfficeCode();
		String officeStr = localCode;
		
		List<ExpRoutinevacc6_1> list_reside = selectResideList(); //1本地    2流动   3临时
		
		List<ExpRoutinevacc6_1> list_community = selectCommunityList(officeStr); //社区
		
		int residesize=list_reside.size();
		int list_communitysize=list_community.size();
		ff = new ArrayList<ExpRoutinevacc6_1>();
		for(int i=0;i<residesize;i++){
			//按居住属性遍历
			for (int j=0;j<list_communitysize;j++){
				//按社区遍历
				ExpRoutinevacc6_1 bb6_1=new ExpRoutinevacc6_1();
				bb6_1.setId(IdGen.uuid());
 				Map<?, ?> mp_reside = (Map<?, ?>) list_reside.get(i);
				String value = (String) mp_reside.get("VALUE"); //获取居住属性
				bb6_1.setReside(value);
				Map<?, ?> mp_community = (Map<?, ?>) list_community.get(j);
				String code = (String) mp_community.get("CODE"); //获取社区code
				bb6_1.setUnitCode(code);
				String name = (String) mp_community.get("NAME"); //获取社区名称
				bb6_1.setUnitName(name);
				String sysCommunityLocalCode = (String) mp_community.get("LOCALCODE"); 
				bb6_1.setLocalCode(sysCommunityLocalCode);
				bb6_1.setYearMonth(createDate);
				ff.add(bb6_1);
			}
		}
		
		List<Map<String, String>> list_rel = new ArrayList<Map<String, String>>();
		list_rel = selectSqlQuery(monthNum + 1, officeStr); //根据设定月份中最后一秒时间节点计算儿童信息
		StringBuffer sbf = new StringBuffer();
		String officeCode = null;
		
		for(int i = 0; i < list_rel.size(); i++){
			Map mp_rel = (Map) list_rel.get(i);
			String id = (String) mp_rel.get("ID");
			String childcode= (String)mp_rel.get("CHILDCODE");
			String mon_age = (String) mp_rel.get("MON_AGE");
			double d_mon_age = Double.parseDouble(mon_age); //月龄
			Date birthday = (Date) mp_rel.get("AAC");  //出生日期(XXXX-XX-XX)
			Date HepB_1_day=null;
			//String pr = (String) mp_rel.get("PR");//省
			//String ci = (String) mp_rel.get("CI");//市
			String co = (String) mp_rel.get("CO");//县
			officeCode = (String) mp_rel.get("OFFICECODE"); //统计区域(用于计算省->市->区树结构)
			String reside=(String) mp_rel.get("RESIDE");//居住属性1本地;2流动;3临时 
			String area=(String) mp_rel.get("AREA");//区域划分
			//System.out.println(mp_rel.get("vage_num"));
			String situation = (String)mp_rel.get("SITUATION");
			String officeInfo = (String) mp_rel.get("OFFICEINFO");
			String create_age = (String) mp_rel.get("CREATE_AGE"); //出生日期与本月间隔

			Map<String, Map<String,String>> vacc_list = new HashMap<String, Map<String, String>>();
			List<Map<String, String>> list_vaccre = new ArrayList<Map<String, String>>();
			list_vaccre = selectSqlList(id,monthNum+1); //根据设定时间,统计所有该儿童已接种的疫苗
			for (int j = 0; j < list_vaccre.size(); j++) {

				Map m_vr = (Map) list_vaccre.get(j);

				String vacc_pin = (String) m_vr.get("VACC_PIN");// 大类+针次
				if(vacc_pin.equals("021")){
					HepB_1_day=(Date) m_vr.get("BBC"); //接种日期
				}
				String office = (String)m_vr.get("OFFICE");
				String source = (String)m_vr.get("SOURCE");
				String vaccineid = (String) m_vr.get("VACCINEID"); 
				String vacc_name = (String) m_vr.get("VACC_NAME"); 
				String dif_mon = (String) m_vr.get("DIF_MON"); //接种间隔
				Map<String, String> t_map = new HashMap<String, String>();
				t_map.put("office", office);
				t_map.put("dif_mon", dif_mon);
				t_map.put("source",source);
			
				vacc_list.put(vacc_pin, t_map);
			}
			
			//卡介特殊处理开始
			Map<String, Map<String, String>> vacc_list_special = new HashMap<String,  Map<String, String>>();
			List<Map<String, String>> list_vaccre_special = new ArrayList<Map<String, String>>();
			list_vaccre_special = selectSqlList(id,monthNum+1); //卡介乙肝处理：将补录记录统计进来
			for (int j = 0; j < list_vaccre_special.size(); j++) {

				Map m_vr_special = (Map) list_vaccre_special.get(j);

				String vacc_pin_special = (String) m_vr_special.get("VACC_PIN");// 大类+针次
				if(vacc_pin_special.equals("021")){
					HepB_1_day=(Date) m_vr_special.get("BBC"); //接种日期
				}
				String office = (String)m_vr_special.get("OFFICE");
				String source = (String)m_vr_special.get("SOURCE");
				String vaccineid_special = (String) m_vr_special.get("VACCINEID"); 
				String vacc_name_special = (String) m_vr_special.get("VACC_NAME"); 
				String dif_mon_special = (String) m_vr_special.get("DIF_MON"); 
				Map<String, String> t_map_2 = new HashMap<String, String>();
				t_map_2.put("office", office);
				t_map_2.put("dif_mon", dif_mon_special);
				t_map_2.put("source",source);
				vacc_list_special.put(vacc_pin_special, t_map_2);
			}
			//卡介特殊处理结束
			
			//应种<13月
			List<Map<String, String>> list_yzrq = new ArrayList<Map<String, String>>();
			Map<String, String> vacc_yzrq = new HashMap<String, String>();
			list_yzrq = selectSqlYzrq(id, monthNum+1);
			
			for(int j = 0; j < list_yzrq.size(); j++){
				Map m_vr = (Map) list_yzrq.get(j);
				String vacc_pin = (String) m_vr.get("ID");// 大类+针次
				String childcode1 = (String) m_vr.get("CHILDCODE");
				vacc_yzrq.put(vacc_pin, childcode1);
			}
			
			//超过7岁龄儿童数据处理开始
			//白破
			/*for (int k = 0; k < ff.size(); k++) {
				if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
					//统计白破疫苗接种时间在生成数据的月份内且当月月龄超过84岁的情况,加入应种实种
					Integer num = get_yuefendayu84_Num("061" , monthNum + 1, reside, area);
					int a = ff.get(k).getDtRe();
					ff.get(k).setDtRe(a+num);
					a = ff.get(k).getDtSh();
					ff.get(k).setDtSh(a+num);
					break;
				}
			}*/
			//超过7岁龄儿童数据处理结束
			
			if(d_mon_age>72){
				//6岁至7岁龄
				
				//卡介
				if(Vacc_in_Map.containsKey("01")){ //根据模型ID = 01 确定是否配置接种 卡介 疫苗
				   do_BCG_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo); //卡介			
				}
				
				//乙肝3
				if(Vacc_in_Map.containsKey("02")){ //根据模型ID = 02 确定是否配置接种 乙肝 疫苗
					do_HepB_3(vacc_list_special, childcode, vacc_yzrq, reside, area, birthday, HepB_1_day, createDate, officeStr, situation ,officeInfo, create_age);
				}
				
				//脊灰3
				if(Vacc_in_Map.containsKey("03")){ //根据模型ID = 03 确定是否配置接种 乙肝 疫苗
					do_PV_4(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//百白破4
				if(Vacc_in_Map.containsKey("04")){
					do_DTP_4(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//A+C群流脑结合2
				if(Vacc_in_Map.containsKey("87")){
					do_MENA_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//A群流脑多糖2
				if(Vacc_in_Map.containsKey("16")){
					do_MPSVA_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//麻风1
				if(Vacc_in_Map.containsKey("14")){
					do_MR_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//乙脑减毒2
				if(Vacc_in_Map.containsKey("84")){
					do_JEL_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//乙脑灭活 4
				if(Vacc_in_Map.containsKey("83")){
					do_JEI_4(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//麻腮风1
				if(Vacc_in_Map.containsKey("12")){
					do_MMR_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//麻腮风2
				if(Vacc_in_Map.containsKey("12")){
					do_MMR_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
			
				//甲肝减毒
				if(Vacc_in_Map.containsKey("82")){
					do_HEPAL_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//甲肝灭活
				if(Vacc_in_Map.containsKey("81")){
					do_HEPAI_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
					
				}
				
				//A+C群多糖第二针
				if(Vacc_in_Map.containsKey("17")){
					do_MENAC_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//白破1
				if(Vacc_in_Map.containsKey("06")){
					do_DT_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
			}else if(d_mon_age>48 && d_mon_age<=72){
				//48-72月

				//卡介
				if(Vacc_in_Map.containsKey("01")){ //根据模型ID = 01 确定是否配置接种 卡介 疫苗
				   do_BCG_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo); //卡介			
				}
				//乙肝3
				if(Vacc_in_Map.containsKey("02")){ //根据模型ID = 02 确定是否配置接种 乙肝 疫苗
					do_HepB_3(vacc_list_special, childcode, vacc_yzrq, reside, area, birthday, HepB_1_day, createDate, officeStr, situation ,officeInfo, create_age);
				}
				
				//脊灰4
				if(Vacc_in_Map.containsKey("03")){ //根据模型ID = 03 确定是否配置接种 乙肝 疫苗
					do_PV_4(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//百白破4
				if(Vacc_in_Map.containsKey("04")){
					do_DTP_4(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//A+C群流脑结合2
				if(Vacc_in_Map.containsKey("87")){
					do_MENA_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//A群流脑多糖2
				if(Vacc_in_Map.containsKey("16")){
					do_MPSVA_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//麻风1
				if(Vacc_in_Map.containsKey("14")){
					do_MR_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//乙脑减毒2
				if(Vacc_in_Map.containsKey("84")){
					do_JEL_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//乙脑灭活 3
				if(Vacc_in_Map.containsKey("83")){
					do_JEI_3(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//麻腮风1
				if(Vacc_in_Map.containsKey("12")){
					do_MMR_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//麻腮风2
				if(Vacc_in_Map.containsKey("12")){
					do_MMR_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
			
				//甲肝减毒
				if(Vacc_in_Map.containsKey("82")){
					do_HEPAL_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				//甲肝灭活
				if(Vacc_in_Map.containsKey("81")){
					do_HEPAI_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//A+C群多糖第一针
				if(Vacc_in_Map.containsKey("17")){
					do_MENAC_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
			}else if(d_mon_age>36 && d_mon_age<=48){
				//36----48
				
				//卡介
				if(Vacc_in_Map.containsKey("01")){ //根据模型ID = 01 确定是否配置接种 卡介 疫苗
				   do_BCG_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo); //卡介			
				}
				//乙肝3
				if(Vacc_in_Map.containsKey("02")){ //根据模型ID = 02 确定是否配置接种 乙肝 疫苗
					do_HepB_3(vacc_list_special, childcode, vacc_yzrq, reside, area, birthday, HepB_1_day, createDate, officeStr, situation ,officeInfo, create_age);
				}
				
				//脊灰3
				if(Vacc_in_Map.containsKey("03")){ //根据模型ID = 03 确定是否配置接种 乙肝 疫苗
					do_PV_3(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
					do_PV_4_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//百白破4
				if(Vacc_in_Map.containsKey("04")){
					do_DTP_4(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//A+C群流脑结合2
				if(Vacc_in_Map.containsKey("87")){
					do_MENA_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//A群流脑多糖2
				if(Vacc_in_Map.containsKey("16")){
					do_MPSVA_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//麻风1
				if(Vacc_in_Map.containsKey("14")){
					do_MR_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				
				//乙脑减毒2
				if(Vacc_in_Map.containsKey("84")){
					do_JEL_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//乙脑灭活 3
				if(Vacc_in_Map.containsKey("83")){
					do_JEI_3(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//麻腮风1
				if(Vacc_in_Map.containsKey("12")){
					do_MMR_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//麻腮风2
				if(Vacc_in_Map.containsKey("12")){
					do_MMR_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
			
				//甲肝减毒
				if(Vacc_in_Map.containsKey("82")){
					do_HEPAL_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//甲肝灭活
				if(Vacc_in_Map.containsKey("81")){
					do_HEPAI_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
					
				}
				//A+C群多糖第一针
				
				if(Vacc_in_Map.containsKey("17")){
					do_MENAC_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
			}else if(d_mon_age>24 && d_mon_age<=36){
				//24-36
				
				//卡介
				if(Vacc_in_Map.containsKey("01")){ //根据模型ID = 01 确定是否配置接种 卡介 疫苗
				   do_BCG_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo); //卡介			
				}
				//乙肝3
				if(Vacc_in_Map.containsKey("02")){ //根据模型ID = 02 确定是否配置接种 乙肝 疫苗
					do_HepB_3(vacc_list_special, childcode, vacc_yzrq, reside, area, birthday, HepB_1_day, createDate, officeStr, situation ,officeInfo, create_age);
				}
				
				//脊灰3
				if(Vacc_in_Map.containsKey("03")){ //根据模型ID = 03 确定是否配置接种 乙肝 疫苗
					do_PV_3(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
					do_PV_4_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//百白破4
				if(Vacc_in_Map.containsKey("04")){
					do_DTP_4(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//A+C群流脑结合2
				if(Vacc_in_Map.containsKey("87")){
					do_MENA_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//A群流脑多糖2
				if(Vacc_in_Map.containsKey("16")){
					do_MPSVA_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//麻风1
				if(Vacc_in_Map.containsKey("14")){
					do_MR_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//乙脑减毒2
				if(Vacc_in_Map.containsKey("84")){
					do_JEL_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//乙脑灭活 3
				if(Vacc_in_Map.containsKey("83")){
					do_JEI_3(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//麻腮风1
				if(Vacc_in_Map.containsKey("12")){
					do_MMR_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//麻腮风2
				if(Vacc_in_Map.containsKey("12")){
					do_MMR_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
			
				//甲肝减毒
				if(Vacc_in_Map.containsKey("82")){
					do_HEPAL_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
					
				}
				//甲肝灭活
				if(Vacc_in_Map.containsKey("81")){
					do_HEPAI_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
					
				}
				
			}else if(d_mon_age>18 && d_mon_age<=24){
				//18月---24月
				
				//卡介
				if(Vacc_in_Map.containsKey("01")){ //根据模型ID = 01 确定是否配置接种 卡介 疫苗
				   do_BCG_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo); //卡介			
				}
				//乙肝3
				if(Vacc_in_Map.containsKey("02")){ //根据模型ID = 02 确定是否配置接种 乙肝 疫苗
					do_HepB_3(vacc_list_special, childcode, vacc_yzrq, reside, area, birthday, HepB_1_day, createDate, officeStr, situation ,officeInfo, create_age);
				}
				
				//脊灰3
				if(Vacc_in_Map.containsKey("03")){ //根据模型ID = 03 确定是否配置接种 乙肝 疫苗
					do_PV_3(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
					do_PV_4_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//百白破4
				if(Vacc_in_Map.containsKey("04")){
					do_DTP_4(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//A+C群流脑结合2
				if(Vacc_in_Map.containsKey("87")){
					do_MENA_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//A群流脑多糖1
				if(Vacc_in_Map.containsKey("16")){
					do_MPSVA_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//麻风1
				if(Vacc_in_Map.containsKey("14")){
					do_MR_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//乙脑减毒1
				if(Vacc_in_Map.containsKey("84")){
					do_JEL_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//乙脑灭活 1-2
				if(Vacc_in_Map.containsKey("83")){
					do_JEI_1_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//麻腮风1
				if(Vacc_in_Map.containsKey("12")){
					do_MMR_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//麻腮风2
				if(Vacc_in_Map.containsKey("12")){
					do_MMR_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
			
				//甲肝减毒
				if(Vacc_in_Map.containsKey("82")){
					do_HEPAL_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				//甲肝灭活
				if(Vacc_in_Map.containsKey("81")){
					do_HEPAI_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
					
				}
				
			}else if(d_mon_age>9 && d_mon_age<=18){			
		
				//8月-----9月  //国家版本的接种A群流脑多糖 第二针
				//卡介
				if(Vacc_in_Map.containsKey("01")){ //根据模型ID = 01 确定是否配置接种 卡介 疫苗
				   do_BCG_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo); //卡介			
				}
				//乙肝3
				if(Vacc_in_Map.containsKey("02")){ //根据模型ID = 02 确定是否配置接种 乙肝 疫苗
					do_HepB_3(vacc_list_special, childcode, vacc_yzrq, reside, area, birthday, HepB_1_day, createDate, officeStr, situation ,officeInfo, create_age);
				}
				
				//脊灰3
				if(Vacc_in_Map.containsKey("03")){ //根据模型ID = 03 确定是否配置接种 乙肝 疫苗
					do_PV_3(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//百白破3
				if(Vacc_in_Map.containsKey("04")){
					do_DTP_3(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//A+C群流脑结合2
				if(Vacc_in_Map.containsKey("87")){
					do_MENA_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//A群流脑多糖2
				if(Vacc_in_Map.containsKey("16")){
					do_MPSVA_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//麻风1
				if(Vacc_in_Map.containsKey("14")){
					do_MR_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				
				//乙脑减毒1
				if(Vacc_in_Map.containsKey("84")){
					do_JEL_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//乙脑灭活 1-2
				if(Vacc_in_Map.containsKey("83")){
					do_JEI_1_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
			}else if(d_mon_age>8 && d_mon_age<=9){
				//8月-----9月 
				//卡介
				if(Vacc_in_Map.containsKey("01")){ //根据模型ID = 01 确定是否配置接种 卡介 疫苗
				   do_BCG_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo); //卡介			
				}
				//乙肝3
				if(Vacc_in_Map.containsKey("02")){ //根据模型ID = 02 确定是否配置接种 乙肝 疫苗
					do_HepB_3(vacc_list_special, childcode, vacc_yzrq, reside, area, birthday, HepB_1_day, createDate, officeStr, situation ,officeInfo, create_age);
				}
				
				//脊灰3
				if(Vacc_in_Map.containsKey("03")){ //根据模型ID = 03 确定是否配置接种 乙肝 疫苗
					do_PV_3(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//百白破3
				if(Vacc_in_Map.containsKey("04")){
					do_DTP_3(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//A+C群流脑结合2
				if(Vacc_in_Map.containsKey("87")){
					do_MENA_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//A群流脑多糖1
				if(Vacc_in_Map.containsKey("16")){
					do_MPSVA_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//麻风1
				if(Vacc_in_Map.containsKey("14")){
					do_MR_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//乙脑减毒1
				if(Vacc_in_Map.containsKey("84")){
					do_JEL_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//乙脑灭活 1-2
				if(Vacc_in_Map.containsKey("83")){
					do_JEI_1_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
			}else if(d_mon_age>7 && d_mon_age<=8){
				//7月-----8月
				
				//卡介
				if(Vacc_in_Map.containsKey("01")){ //根据模型ID = 01 确定是否配置接种 卡介 疫苗
				   do_BCG_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo); //卡介			
				}
				//乙肝3
				if(Vacc_in_Map.containsKey("02")){ //根据模型ID = 02 确定是否配置接种 乙肝 疫苗
					do_HepB_3(vacc_list_special, childcode, vacc_yzrq, reside, area, birthday, HepB_1_day, createDate, officeStr, situation ,officeInfo, create_age);
				}
				
				//脊灰3
				if(Vacc_in_Map.containsKey("03")){ //根据模型ID = 03 确定是否配置接种 乙肝 疫苗
					do_PV_3(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//百白破3
				if(Vacc_in_Map.containsKey("04")){
					do_DTP_3(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//A+C群流脑结合2
				if(Vacc_in_Map.containsKey("87")){
					do_MENA_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//A群流脑多糖1
				if(Vacc_in_Map.containsKey("16")){
					do_MPSVA_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
			}else if(d_mon_age>6 && d_mon_age<=7){
				//6月------7月
				
				//卡介
				if(Vacc_in_Map.containsKey("01")){ //根据模型ID = 01 确定是否配置接种 卡介 疫苗
				   do_BCG_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo); //卡介			
				}
				//乙肝3
				if(Vacc_in_Map.containsKey("02")){ //根据模型ID = 02 确定是否配置接种 乙肝 疫苗
					do_HepB_3(vacc_list_special, childcode, vacc_yzrq, reside, area, birthday, HepB_1_day, createDate, officeStr, situation ,officeInfo, create_age);
				}
				
				//脊灰3
				if(Vacc_in_Map.containsKey("03")){ //根据模型ID = 03 确定是否配置接种 乙肝 疫苗
					do_PV_3(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//百白破3
				if(Vacc_in_Map.containsKey("04")){
					do_DTP_3(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//A+C群流脑结合1
				if(Vacc_in_Map.containsKey("87")){
					do_MENA_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//A群流脑多糖1
				if(Vacc_in_Map.containsKey("16")){
					do_MPSVA_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				
				
			}else if(d_mon_age>5 && d_mon_age<=6){
				//5月  ----6 月
				
				//卡介
				if(Vacc_in_Map.containsKey("01")){ //根据模型ID = 01 确定是否配置接种 卡介 疫苗
				   do_BCG_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo); //卡介			
				}
				
				//乙肝2
				if(Vacc_in_Map.containsKey("02")){ //根据模型ID = 02 确定是否配置接种 乙肝 疫苗
					do_HepB_2(vacc_list_special, childcode, vacc_yzrq, reside, area, birthday, HepB_1_day, createDate, officeStr, situation ,officeInfo, create_age);
				}
				
				//脊灰3
				if(Vacc_in_Map.containsKey("03")){ //根据模型ID = 03 确定是否配置接种 乙肝 疫苗
					do_PV_3(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//百白破3
				if(Vacc_in_Map.containsKey("04")){
					do_DTP_3(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//A+C群流脑结合1 对AC-Hib拆解的疫苗做殊处理
				if(Vacc_in_Map.containsKey("87")){
					do_MENA_1_Special(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
			}else if(d_mon_age>4 && d_mon_age<=5){
				//4月 ------ 5月
				
				//卡介
				if(Vacc_in_Map.containsKey("01")){ //根据模型ID = 01 确定是否配置接种 卡介 疫苗
				   do_BCG_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo); //卡介			
				}
				//乙肝2
				if(Vacc_in_Map.containsKey("02")){ //根据模型ID = 02 确定是否配置接种 乙肝 疫苗
					do_HepB_2(vacc_list_special, childcode, vacc_yzrq, reside, area, birthday, HepB_1_day, createDate, officeStr, situation ,officeInfo, create_age);
				}
				
				//脊灰3
				if(Vacc_in_Map.containsKey("03")){ //根据模型ID = 03 确定是否配置接种 乙肝 疫苗
					do_PV_3(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//百白破2
				if(Vacc_in_Map.containsKey("04")){
					do_DTP_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//A+C群流脑结合1 对AC-Hib拆解的疫苗做殊处理
				if(Vacc_in_Map.containsKey("87")){
					do_MENA_1_Special(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				
			}else if(d_mon_age>3 && d_mon_age<=4){
				//3月-------4月
				
				//卡介
				if(Vacc_in_Map.containsKey("01")){ //根据模型ID = 01 确定是否配置接种 卡介 疫苗
				   do_BCG_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo); //卡介			
				}
				//乙肝2
				if(Vacc_in_Map.containsKey("02")){ //根据模型ID = 02 确定是否配置接种 乙肝 疫苗
					do_HepB_2(vacc_list_special, childcode, vacc_yzrq, reside, area, birthday, HepB_1_day, createDate, officeStr, situation ,officeInfo, create_age);
				}
				
				//脊灰2
				if(Vacc_in_Map.containsKey("03")){ //根据模型ID = 03 确定是否配置接种 乙肝 疫苗
					do_PV_2(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//百白破1
				if(Vacc_in_Map.containsKey("04")){
					do_DTP_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//A+C群流脑结合1 对AC-Hib拆解的疫苗做殊处理
				if(Vacc_in_Map.containsKey("87")){
					do_MENA_1_Special(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
			}else if(d_mon_age>2 && d_mon_age<=3){
				//2月-----3月
				
				//卡介
				if(Vacc_in_Map.containsKey("01")){ //根据模型ID = 01 确定是否配置接种 卡介 疫苗
				   do_BCG_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo); //卡介			
				}
				//乙肝2
				if(Vacc_in_Map.containsKey("02")){ //根据模型ID = 02 确定是否配置接种 乙肝 疫苗
					do_HepB_2(vacc_list_special, childcode, vacc_yzrq, reside, area, birthday, HepB_1_day, createDate, officeStr, situation ,officeInfo, create_age);
				}
				
				//脊灰
				if(Vacc_in_Map.containsKey("03")){ //根据模型ID = 03 确定是否配置接种 脊灰 疫苗
					do_PV_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
				//A+C群流脑结合1 对AC-Hib拆解的疫苗做殊处理
				if(Vacc_in_Map.containsKey("87")){
					do_MENA_1_Special(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo);
				}
				
			}else if(d_mon_age>1 && d_mon_age<=2){
				//1月------2月
				
				//卡介
				if(Vacc_in_Map.containsKey("01")){ //根据模型ID = 01 确定是否配置接种 卡介 疫苗
				   do_BCG_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo); //卡介			
				}
				//乙肝2
				if(Vacc_in_Map.containsKey("02")){ //根据模型ID = 02 确定是否配置接种 乙肝 疫苗
					do_HepB_2(vacc_list_special, childcode, vacc_yzrq, reside, area, birthday, HepB_1_day, createDate, officeStr, situation ,officeInfo, create_age);
				}
			}else if(d_mon_age>0 && d_mon_age<=1){
				//0月 ------1月
				
				//卡介
				if(Vacc_in_Map.containsKey("01")){ //根据模型ID = 01 确定是否配置接种 卡介 疫苗
				   do_BCG_1(vacc_list_special, childcode, vacc_yzrq, reside, area, createDate, officeStr, situation ,officeInfo); //卡介			
				}
				//乙肝1
				if(Vacc_in_Map.containsKey("02")){ //根据模型ID = 02 确定是否配置接种 乙肝 疫苗
					do_HepB_1(vacc_list_special, childcode, vacc_yzrq, reside, area, birthday, HepB_1_day ,createDate, officeStr, situation, officeInfo);
				}
			}
			
		}
		
		DecimalFormat df = new DecimalFormat("#.0000");
		for(int k = 0; k < ff.size(); k++){
			
			//设置乙肝及时数为乙肝第一针数
			ff.get(k).setHepbAaSh(ff.get(k).getHepbASh());
			
//			根据实种、应种,计算接种率	
			if(ff.get(k).getHepbASh() != 0){
				ff.get(k).setHepbASr( Float.parseFloat(df.format( (float) ff.get(k).getHepbARe() / ff.get(k).getHepbASh()))*100);
			}
			
			if(ff.get(k).getHepbAaSh() != 0){
				ff.get(k).setHepbAaSr(Float.parseFloat(df.format((float) ff.get(k).getHepbAaRe() / ff.get(k).getHepbAaSh()))*100);
			}
			
			if(ff.get(k).getHepbBSh() != 0){
				ff.get(k).setHepbBSr(Float.parseFloat(df.format((float) ff.get(k).getHepbBRe() / ff.get(k).getHepbBSh()))*100);
			}
			
			if(ff.get(k).getHepbCSh() != 0){
				ff.get(k).setHepbCSr(Float.parseFloat(df.format((float) ff.get(k).getHepbCRe() / ff.get(k).getHepbCSh()))*100);
			}
			
			if(ff.get(k).getBcgSh() != 0){
				ff.get(k).setBcgSr(Float.parseFloat(df.format((float) ff.get(k).getBcgRe() / ff.get(k).getBcgSh()))*100);
			}
			
			if(ff.get(k).getPvASh() != 0){
				ff.get(k).setPvASr(Float.parseFloat(df.format((float) ff.get(k).getPvARe() / ff.get(k).getPvASh()))*100);
			}
			
			if(ff.get(k).getPvBSh() != 0){
				ff.get(k).setPvBSr(Float.parseFloat(df.format((float) ff.get(k).getPvBRe() / ff.get(k).getPvBSh()))*100);
			}
			
			if(ff.get(k).getPvBSh() != 0){
				ff.get(k).setPvBSr(Float.parseFloat(df.format((float) ff.get(k).getPvBRe() / ff.get(k).getPvBSh()))*100);
			}
			if(ff.get(k).getPvDSh() != 0){
				ff.get(k).setPvDSr(Float.parseFloat(df.format((float) ff.get(k).getPvDRe() / ff.get(k).getPvDSh()))*100);
			}
			if(ff.get(k).getDtpASh() != 0){
				ff.get(k).setDtpASr(Float.parseFloat(df.format((float) ff.get(k).getDtpARe() / ff.get(k).getDtpASh()))*100);
			}
			
			if(ff.get(k).getDtpBSh() != 0){
				ff.get(k).setDtpBSr(Float.parseFloat(df.format((float) ff.get(k).getDtpBRe() / ff.get(k).getDtpBSh()))*100);
			}
			
			if(ff.get(k).getDtpCSh() != 0){
				ff.get(k).setDtpCSr(Float.parseFloat(df.format((float) ff.get(k).getDtpCRe() / ff.get(k).getDtpCSh()))*100);
			}
			
			if(ff.get(k).getDtpDSh() != 0){
				ff.get(k).setDtpDSr(Float.parseFloat(df.format((float) ff.get(k).getDtpDRe() / ff.get(k).getDtpDSh()))*100);
			}
			
			if(ff.get(k).getDtSh() != 0){
				ff.get(k).setDtSr(Float.parseFloat(df.format((float) ff.get(k).getDtRe() / ff.get(k).getDtSh()))*100);
			}
			
			if(ff.get(k).getMrASh() != 0){
				ff.get(k).setMrASr(Float.parseFloat(df.format((float) ff.get(k).getMrARe() / ff.get(k).getMrASh()))*100);
			}
			
			if(ff.get(k).getMrBSh() != 0){
				ff.get(k).setMrBSr(Float.parseFloat(df.format((float) ff.get(k).getMrBRe() / ff.get(k).getMrBSh()))*100);
			}
			
			if(ff.get(k).getMmrASh() != 0){
				ff.get(k).setMmrASr(Float.parseFloat(df.format((float) ff.get(k).getMmrARe() / ff.get(k).getMmrASh()))*100);
			}
			
			if(ff.get(k).getMmrBSh() != 0){
				ff.get(k).setMmrBSr(Float.parseFloat(df.format((float) ff.get(k).getMmrBRe() / ff.get(k).getMmrBSh()))*100);
			}
			
			if(ff.get(k).getMmASh() != 0){
				ff.get(k).setMmASr(Float.parseFloat(df.format((float) ff.get(k).getMmARe() / ff.get(k).getMmASh()))*100);
			}
			
			if(ff.get(k).getMmBSh() != 0){
				ff.get(k).setMmBSr(Float.parseFloat(df.format((float) ff.get(k).getMmBRe() / ff.get(k).getMmBSh()))*100);
			}
			
			if(ff.get(k).getMvASh() != 0){
				ff.get(k).setMvASr(Float.parseFloat(df.format((float) ff.get(k).getMvARe() / ff.get(k).getMvASh()))*100);
			}
			
			if(ff.get(k).getMvBSh() != 0){
				ff.get(k).setMvBSr(Float.parseFloat(df.format((float) ff.get(k).getMvBRe() / ff.get(k).getMvBSh()))*100);
			}
			
			if(ff.get(k).getMenaASh() != 0){
				ff.get(k).setMenaASr(Float.parseFloat(df.format((float) ff.get(k).getMenaARe() / ff.get(k).getMenaASh()))*100);
			}
			
			if(ff.get(k).getMenaBSh() != 0){
				ff.get(k).setMenaBSr(Float.parseFloat(df.format((float) ff.get(k).getMenaBRe() / ff.get(k).getMenaBSh()))*100);
			}
			
			if(ff.get(k).getMenacASh() != 0){
				ff.get(k).setMenacASr(Float.parseFloat(df.format((float) ff.get(k).getMenacARe() / ff.get(k).getMenacASh()))*100);
			}
			
			if(ff.get(k).getMenacBSh() != 0){
				ff.get(k).setMenacBSr(Float.parseFloat(df.format((float) ff.get(k).getMenacBRe() / ff.get(k).getMenacBSh()))*100);
			}
			
			if(ff.get(k).getJelASh() != 0){
				ff.get(k).setJelASr(Float.parseFloat(df.format((float) ff.get(k).getJelARe() / ff.get(k).getJelASh()))*100);
			}
			
			if(ff.get(k).getJelBSh() != 0){
				ff.get(k).setJelBSr(Float.parseFloat(df.format((float) ff.get(k).getJelBRe() / ff.get(k).getJelBSh()))*100);
			}
			
			if(ff.get(k).getJeiASh() != 0){
				ff.get(k).setJeiASr(Float.parseFloat(df.format((float) ff.get(k).getJeiARe() / ff.get(k).getJeiASh()))*100);
			}
			
			if(ff.get(k).getJeiBSh() != 0){
				ff.get(k).setJeiBSr(Float.parseFloat(df.format((float) ff.get(k).getJeiBRe() / ff.get(k).getJeiBSh()))*100);
			}
			
			if(ff.get(k).getJeiCSh() != 0){
				ff.get(k).setJeiCSr(Float.parseFloat(df.format((float) ff.get(k).getJeiCRe() / ff.get(k).getJeiCSh()))*100);
			}
			
			if(ff.get(k).getJeiDSh() != 0){
				ff.get(k).setJeiDSr(Float.parseFloat(df.format((float) ff.get(k).getJeiDRe() / ff.get(k).getJeiDSh()))*100);
			}
			
			if(ff.get(k).getHepalSh() != 0){
				ff.get(k).setHepalSr(Float.parseFloat(df.format((float) ff.get(k).getHepalRe() / ff.get(k).getHepalSh()))*100);
			}
			
			if(ff.get(k).getHepaiASh() != 0){
				ff.get(k).setHepaiASr(Float.parseFloat(df.format((float) ff.get(k).getHepaiARe() / ff.get(k).getHepaiASh()))*100);
			}
			
			if(ff.get(k).getHepaiBSh() != 0){
				ff.get(k).setHepaiBSr(Float.parseFloat(df.format((float) ff.get(k).getHepaiBRe() / ff.get(k).getHepaiBSh()))*100);
			}
			
			//计算MCV,RCV,MumCV,HepA类型总和接种率
			ff.get(k).setMcvSumASh(ff.get(k).getMvASh() + ff.get(k).getMrASh() + ff.get(k).getMmASh() + ff.get(k).getMmrASh());
			ff.get(k).setMcvSumARe(ff.get(k).getMvARe() + ff.get(k).getMrARe() + ff.get(k).getMmARe() + ff.get(k).getMmrARe());
			ff.get(k).setMcvSumBSh(ff.get(k).getMvSumBSh() + ff.get(k).getMrSumBSh() + ff.get(k).getMmSumBSh() + ff.get(k).getMmrBSh());
			ff.get(k).setMcvSumBRe(ff.get(k).getMvBRe() + ff.get(k).getMrBRe() + ff.get(k).getMmBRe() + ff.get(k).getMmrBRe());		
			
			ff.get(k).setRcvSumASh(ff.get(k).getMrASh() + ff.get(k).getMmrASh());
			ff.get(k).setRcvSumARe(ff.get(k).getMrARe() + ff.get(k).getMmrARe());
			ff.get(k).setRcvSumBSh(ff.get(k).getMrSumBSh() + ff.get(k).getMmrBSh());
			ff.get(k).setRcvSumBRe(ff.get(k).getMrBRe() + ff.get(k).getMmrBRe());
			
			ff.get(k).setMumcvSumASh(ff.get(k).getMmASh() + ff.get(k).getMmrASh());
			ff.get(k).setMumcvSumARe(ff.get(k).getMmARe() + ff.get(k).getMmrARe());
			ff.get(k).setMumcvSumBSh(ff.get(k).getMmBSh() + ff.get(k).getMmrBSh());
			ff.get(k).setMumcvSumBRe(ff.get(k).getMmBRe() + ff.get(k).getMmrBRe());
			
			ff.get(k).setHepalSumASh(ff.get(k).getHepalSh());
			ff.get(k).setHepalSumARe(ff.get(k).getHepalRe());
			
			ff.get(k).setHepaiSumASh(ff.get(k).getHepaiASh());
			ff.get(k).setHepaiSumARe(ff.get(k).getHepaiARe());
			ff.get(k).setHepaiSumBSh(ff.get(k).getHepaiBSh());
			ff.get(k).setHepaiSumBRe(ff.get(k).getHepaiBRe());
			
			if(ff.get(k).getMcvSumASh() != 0){
				ff.get(k).setMcvSumASr(Float.parseFloat(df.format((float) ff.get(k).getMcvSumARe() / ff.get(k).getMcvSumASh()))*100);
			}
			if(ff.get(k).getMcvSumBSh() != 0){
				ff.get(k).setMcvSumBSr(Float.parseFloat(df.format((float) ff.get(k).getMcvSumBRe() / ff.get(k).getMcvSumBSh()))*100);
			}
			
			if(ff.get(k).getRcvSumASh() != 0){
				ff.get(k).setRcvSumASr(Float.parseFloat(df.format((float) ff.get(k).getRcvSumARe() / ff.get(k).getRcvSumASh()))*100);
			}
			if(ff.get(k).getRcvSumBSh() != 0){
				ff.get(k).setRcvSumBSr(Float.parseFloat(df.format((float) ff.get(k).getRcvSumBRe() / ff.get(k).getRcvSumBSh()))*100);
			}
			
			if(ff.get(k).getMumcvSumASh() != 0){
				ff.get(k).setMumcvSumASr(Float.parseFloat(df.format((float) ff.get(k).getMumcvSumARe() / ff.get(k).getMumcvSumASh()))*100);
			}
			if(ff.get(k).getMumcvSumBSh() != 0){
				ff.get(k).setMumcvSumBSr(Float.parseFloat(df.format((float) ff.get(k).getMumcvSumBRe() / ff.get(k).getMumcvSumBSh()))*100);
			}
			
			if(ff.get(k).getHepalSumASh() != 0 ){
				ff.get(k).setHepalSumASr(Float.parseFloat(df.format((float) ff.get(k).getHepalSumARe() / ff.get(k).getHepalSumASh()))*100);
			}
			
			if(ff.get(k).getHepaiSumASh() != 0){
				ff.get(k).setHepaiSumASr(Float.parseFloat(df.format((float) ff.get(k).getHepaiSumARe() / ff.get(k).getHepaiSumASh()))*100);
			}
			if(ff.get(k).getHepaiSumBSh() != 0){
				ff.get(k).setHepaiSumBSr(Float.parseFloat(df.format((float) ff.get(k).getHepaiSumBRe() / ff.get(k).getHepaiSumBSh()))*100);
			}
			
			ff.get(k).setOfficecode(officeCode);
			ff.get(k).setIsNewRecord(true);
			save(ff.get(k));
		}
		
		ff = null;
		System.out.println("年" + yearStr + "月" + monthStr);
	}
		
	
	//------------------------------------------------------------------------------------------------------------------------------------------------------
	/**
	 * 根据接种记录按月龄遍历全部数据
	 * @author Jack
	 * @date 2017年10月18日 下午8:05:12
	 * @description 
	 * @param vacc_list
	 * @param childcode 儿童编码
	 * @param vacc_yzrq <br> ID:疫苗大类+剂次<br> CHILDCODE:儿童编码
	 * @param reside 居住属性
	 * @param area 
	 * @param createDate 接种记录创建时间
	 * @param commName 社区名称
	 *
	 */
	//------------------------------------------------------------------------------------------------------------------------------------------------------
	
	/**
	 * **乙肝1和卡介苗的sql计算公式：
	 *	*当月实际产生的记录：
	 *		--当月应种：当月新生儿数量------>应种+1
	 *		--当月实种：当月新生儿中接种了乙肝1(或卡介)的数量------>实种+1
	 *	*当月建卡产生的记录：
	 *		sql统计当月建卡中所有已种乙肝1(或卡介)苗且出生日期不在当月的记录数量------>应种实种都+1
	 * @author Jack
	 * @date 2018年1月26日 下午4:08:00
	 * @description 
	 */
//	public void do_BCG_1(String reside,String area) {
		
		//根据提供的月份间隔 计算当月的新生儿数(当月基本应种数)
//		Integer baseShNum =  getNewChildNumByMonth(monthNum, monthNum + 1);
		
		//当月新生儿中接种了乙肝1(或卡介)的数量(当月基本实种数)
//		Integer baseReNum = getReNumByVaccAndMonth("0101", monthNum, monthNum + 1);
		
		//sql统计当月建卡中所有已种乙肝1(或卡介)苗且出生日期不在当月的记录数量------>应种实种都+1
//		Integer jiankaNum = getJianKaNum("0101", monthNum, monthNum + 1);
		
		
//		for (int k = 0; k < ff.size(); k++) {
//			if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
//				
//				ff.get(k).setBcgSh(baseShNum + jiankaNum);
//				ff.get(k).setBcgRe(baseReNum + jiankaNum); 
//				break;
//			}
//		}
//		
//	}
	
	// 卡介1
	public void do_BCG_1( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area, String createDate, String office, String situation, String officeInfo) {
		
		//////////// 0月龄开始 ///////////
		Map<String, String> t_map = (Map<String, String>) vacc_list.get("011");
		if (t_map == null) {
			if (vacc_yzrq.containsKey("011") && situation.equals("1") && officeInfo.equals(office)) {
				// 卡介苗
				Y_BD_BCG_Map.put(childcode, vacc_list.get("011"));
				// System.out.println("卡介应种");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getBcgSh();
						ff.get(k).setBcgSh(++a);
						break;
					}
				}
			}
		} else {
			if (Double.parseDouble((String) t_map.get("dif_mon")) < 1 ) {
				// 判断接种时间是否在当月
				Y_BD_BCG_Map.put(childcode, "011");
				S_BD_BCG_Map.put(childcode, "011");
				
				// System.out.println(">>>卡介疫苗1应种实种 >>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getBcgRe();
						ff.get(k).setBcgRe(++a);
						a = ff.get(k).getBcgSh();
						ff.get(k).setBcgSh(++a);
						break;
					}
				}
			}
		}

	}

	// 乙肝第一针
	public void do_HepB_1( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area,
			Date birthday,Date HepB_1_day, String createDate, String office, String situation, String officeInfo) {
		
		Map<String, String> t_map = (Map<String, String>) vacc_list.get("021");

		// 判断乙肝第一针是否接种
		if (t_map != null) {
			// 第一针乙肝不为空
			if (Double.parseDouble((String) t_map.get("dif_mon")) < 1 ) {
				// 判断第一针接种时间是否在当月

				// 乙肝1针次是应种针次
				Y_BD_HepB1_Map.put(childcode, "021");
				S_BD_HepB1_Map.put(childcode, "021");
				// System.out.println(">>>乙肝疫苗1应种实种 >>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getHepbARe();
						ff.get(k).setHepbARe(++a);
						a = ff.get(k).getHepbASh();
						ff.get(k).setHepbASh(++a);
						if ((int) ((HepB_1_day.getTime() - birthday.getTime()) / 1000 / 60 / 60 / 24) <= 2) {
							a = ff.get(k).getHepbAaRe();
							ff.get(k).setHepbAaRe(++a);
						}
						break;
					}
				}
			}
		} else {
			// 第一针乙肝为空
			// 乙肝第1针次是应种
			if (vacc_yzrq.containsKey("021") && situation.equals("1") && officeInfo.equals(office)) {
				Y_BD_HepB1_Map.put(childcode, "021");
				// System.out.println(">>>乙肝疫苗1应种 >>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getHepbASh();
						ff.get(k).setHepbASh(++a);
						break;
					}
				}
			}

		}

	}

	// 乙肝第二针
	public void do_HepB_2( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area, 
			Date birthday,Date HepB_1_day, String createDate, String office, String situation, String officeInfo, String create_age_t) {

		Map<String, String> t_map_2 = (Map<String, String>) vacc_list.get("022");
		
		// 判断乙肝第二针是否有接种纪录
		if (t_map_2 != null) {
			// 乙肝第二针已经有接种纪录
			if (Double.parseDouble((String) t_map_2.get("dif_mon")) < 1 
					&& t_map_2.get("office").equals(office) && !(t_map_2.get("source").equals("3"))) {
				// 判断第二针接种时间是否在当月
				
				// 乙肝2针次是应种针次
				Y_BD_HepB2_Map.put(childcode, "022");
				S_BD_HepB2_Map.put(childcode, "022");
				
				// System.out.println(">>>乙肝疫苗2应种 实种>>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getHepbBRe();
						ff.get(k).setHepbBRe(++a);
						a = ff.get(k).getHepbBSh();
						ff.get(k).setHepbBSh(++a);
						break;
					}
				}
				
				//加入当月建卡的乙肝第一针数据统计
				if(Double.valueOf(create_age_t) < 1){
					//建卡月份在当月的记录
					// 乙肝1针次是应种针次
					Y_BD_HepB1_Map.put(childcode, "021");
					S_BD_HepB1_Map.put(childcode, "021");
					// System.out.println(">>>乙肝疫苗1应种实种 >>>");
					for (int k = 0; k < ff.size(); k++) {
						if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
							
							int a = ff.get(k).getHepbARe();
							ff.get(k).setHepbARe(++a);
							a = ff.get(k).getHepbASh();
							ff.get(k).setHepbASh(++a);
							if ((int) ((HepB_1_day.getTime() - birthday.getTime()) / 1000 / 60 / 60 / 24) <= 2) {
								a = ff.get(k).getHepbAaRe();
								ff.get(k).setHepbAaRe(++a);
							}
							break;
						}
					}
				}
			}
			
		} else {
			Map<String, String> t_map_1 = (Map<String, String>) vacc_list.get("021");
			
			// 判断乙肝第一针是否接种
			if (t_map_1 != null) {
				// 第一针乙肝不为空
				if (Double.parseDouble((String) t_map_1.get("dif_mon")) < 1 ) {
					// 判断第一针接种时间是否在当月

					// 乙肝1针次是应种实种针次
					Y_BD_HepB1_Map.put(childcode, "021");
					S_BD_HepB1_Map.put(childcode, "021");
					// System.out.println(">>>乙肝疫苗1应种实种 >>>");
					for (int k = 0; k < ff.size(); k++) {
						if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
							
							int a = ff.get(k).getHepbARe();
							ff.get(k).setHepbARe(++a);
							a = ff.get(k).getHepbASh();
							ff.get(k).setHepbASh(++a);
							if ((int) ((HepB_1_day.getTime() - birthday.getTime()) / 1000 / 60 / 60 / 24) <= 2) {
								a = ff.get(k).getHepbAaRe();
								ff.get(k).setHepbAaRe(++a);
							}
							break;
						}
					}
				} else {
					if (vacc_yzrq.containsKey("022")  && situation.equals("1") && officeInfo.equals(office)) {
						// 乙肝2针次是应种针次
						Y_BD_HepB2_Map.put(childcode, "022");
						
						// System.out.println(">>>乙肝疫苗2应种 >>>");
						for (int k = 0; k < ff.size(); k++) {
							if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
								
								int a = ff.get(k).getHepbBSh();
								ff.get(k).setHepbBSh(++a);
								break;
							}
						}
					}
				}

			} else {
				if (vacc_yzrq.containsKey("021")  && situation.equals("1") && officeInfo.equals(office)) {
					// 第一针乙肝为空
					// 乙肝第1针次是应种
					Y_BD_HepB1_Map.put(childcode, "021");
					// System.out.println(">>>乙肝疫苗1应种 >>>");
					for (int k = 0; k < ff.size(); k++) {
						if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
							
							int a = ff.get(k).getHepbASh();
							ff.get(k).setHepbASh(++a);
							break;
						}
					}
				}

			}
		}

	}

	// 大于6月龄的三针乙肝
	public void do_HepB_3( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area,
			Date birthday,Date HepB_1_day, String createDate, String office, String situation, String officeInfo, String create_age_t) {
		
		Map<String, String> t_map_3 = (Map<String, String>) vacc_list.get("023");
		Map<String, String> t_map_2 = (Map<String, String>) vacc_list.get("022");
		Map<String, String> t_map_1 = (Map<String, String>) vacc_list.get("021");
		

		if (t_map_3 != null) {
			// 乙肝第三针有接种纪录

			if (Double.parseDouble((String) t_map_3.get("dif_mon")) < 1 
					&& t_map_3.get("office").equals(office) && !(t_map_3.get("source").equals("3"))) {
				// 判断接种时间是否在当月
				Y_BD_HepB3_Map.put(childcode, "023");
				S_BD_HepB3_Map.put(childcode, "023");
				// System.out.println(">>>乙肝疫苗3应种实种 >>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getHepbCRe();
						ff.get(k).setHepbCRe(++a);
						a = ff.get(k).getHepbCSh();
						ff.get(k).setHepbCSh(++a);
						break;
					}
				}
			} else {
				// System.out.println(">>>乙肝疫苗3很早就接种了 >>>");
			}
		} else {
			
			// 判断乙肝第二针是否有接种纪录
			if (t_map_2 != null) {
				// 乙肝第二针已经有接种纪录
				if (Double.parseDouble((String) t_map_2.get("dif_mon")) < 1 
						&& t_map_2.get("office").equals(office) && !(t_map_2.get("source").equals("3"))) {
					// 判断第二针接种时间是否在当月

					// 乙肝针次是应种针次
					Y_BD_HepB2_Map.put(childcode, "022");
					S_BD_HepB2_Map.put(childcode, "022");
					
					// System.out.println(">>>乙肝疫苗2应种实种 >>>");
					for (int k = 0; k < ff.size(); k++) {
						if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
							
							int a = ff.get(k).getHepbBRe();
							ff.get(k).setHepbBRe(++a);
							a = ff.get(k).getHepbBSh();
							ff.get(k).setHepbBSh(++a);
							break;
						}
					}
					
					
					//加入当月建卡的乙肝第一针数据统计
					if(Double.valueOf(create_age_t) < 1){
						//建卡月份在当月的记录
						// 乙肝1针次是应种针次
						Y_BD_HepB1_Map.put(childcode, "021");
						S_BD_HepB1_Map.put(childcode, "021");
						// System.out.println(">>>乙肝疫苗1应种实种 >>>");
						for (int k = 0; k < ff.size(); k++) {
							if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
								
								int a = ff.get(k).getHepbARe();
								ff.get(k).setHepbARe(++a);
								a = ff.get(k).getHepbASh();
								ff.get(k).setHepbASh(++a);
								if ((int) ((HepB_1_day.getTime() - birthday.getTime()) / 1000 / 60 / 60 / 24) <= 2) {
									a = ff.get(k).getHepbAaRe();
									ff.get(k).setHepbAaRe(++a);
								}
								break;
							}
						}
					}
					
				} else {
					if (vacc_yzrq.containsKey("023")  && situation.equals("1") && officeInfo.equals(office)) {
						if(t_map_1 != null && t_map_2 != null){
							if ((Double.parseDouble((String) t_map_2.get("dif_mon")) > 2)
									&& Double.parseDouble((String) t_map_1.get("dif_mon")) >6 ) {
								// 乙肝第二针三个月且第一针6个月，则第三针次是应种
								Y_BD_HepB3_Map.put(childcode, "023");
								// System.out.println(">>>乙肝疫苗3应种 >>>");
								for (int k = 0; k < ff.size(); k++) {
									if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
										
										int a = ff.get(k).getHepbCSh();
										ff.get(k).setHepbCSh(++a);
										break;
									}
								}
							} else {
								// System.out.println(">>>乙肝疫苗3未到间隔 >>>");
							}
						}
					}
				}
			} else {
				
				// 判断乙肝第一针是否接种
				if (t_map_1 != null) {
					// 第一针乙肝不为空
					if (Double.parseDouble((String) t_map_1.get("dif_mon")) < 1) {
						// 判断第一针接种时间是否在当月

						// 乙肝1针次是应种针次
						Y_BD_HepB1_Map.put(childcode, "021");
						S_BD_HepB1_Map.put(childcode, "021");
						// System.out.println(">>>乙肝疫苗1应种实种 >>>");
						for (int k = 0; k < ff.size(); k++) {
							if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
								
								int a = ff.get(k).getHepbARe();
								ff.get(k).setHepbARe(++a);
								a = ff.get(k).getHepbASh();
								ff.get(k).setHepbASh(++a);
								if ((int) ((HepB_1_day.getTime() - birthday.getTime()) / 1000 / 60 / 60 / 24) <= 2) {
									a = ff.get(k).getHepbAaRe();
									ff.get(k).setHepbAaRe(++a);
								}
								break;
							}
						}
					} else {
						if (vacc_yzrq.containsKey("022")  && situation.equals("1") && officeInfo.equals(office)) {
							// 乙肝2针次是应种针次
							Y_BD_HepB2_Map.put(childcode, "022");
							// System.out.println(">>>乙肝疫苗2应种 >>>");
							for (int k = 0; k < ff.size(); k++) {
								if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
									
									int a = ff.get(k).getHepbBSh();
									ff.get(k).setHepbBSh(++a);
									break;
								}
							}
						}
					}

				} else {
					if (vacc_yzrq.containsKey("021")  && situation.equals("1") && officeInfo.equals(office)) {
						// 第一针乙肝为空
						// 乙肝第1针次是应种
						Y_BD_HepB1_Map.put(childcode, "021");
						// System.out.println(">>>乙肝疫苗1应种 >>>");
						for (int k = 0; k < ff.size(); k++) {
							if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
								
								int a = ff.get(k).getHepbASh();
								ff.get(k).setHepbASh(++a);
								break;
							}
						}
					}
				}
			}

		}

	}

	// 脊灰第一针 2月龄
	public void do_PV_1( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area, String createDate, String office, String situation, String officeInfo){
		
		Map<String, String> t_map_1 = (Map<String, String>) vacc_list.get("031");

		// 判断脊灰疫苗第1 针是否接种
		if (t_map_1 != null) {
			// 第一针脊灰不为空
			if (Double.parseDouble((String) t_map_1.get("dif_mon")) < 1
					&& t_map_1.get("office").equals(office) && !(t_map_1.get("source").equals("3"))) {
				// 判断第1针接种是否在当月

				// 脊灰1针次是应种针次
				Y_BD_PV1_Map.put(childcode, "031");
				S_BD_PV1_Map.put(childcode, "031");
				// System.out.println(">>>脊灰疫苗1应种实种>>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getPvARe();
						ff.get(k).setPvARe(++a);
						a = ff.get(k).getPvASh();
						ff.get(k).setPvASh(++a);
						break;
					}
				}
			} else {
				// 第一针脊灰不为空 接种日期比较早
				// System.out.println(">>>脊灰疫苗1已经接种很久了 >>>");
			}
		} else {

			if (vacc_yzrq.containsKey("031")  && situation.equals("1") && officeInfo.equals(office)) {
				// 脊灰第1针次是应种
				Y_BD_PV1_Map.put(childcode, "031");
				// System.out.println(">>>脊灰疫苗1应种 >>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getPvASh();
						ff.get(k).setPvASh(++a);
						break;
					}
				}
			}
			

		}

	}

	// 脊灰第二针3月龄
	public void do_PV_2( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area, String createDate, String office, String situation, String officeInfo){
		
		Map<String, String> t_map_2 = (Map<String, String>) vacc_list.get("032");

		// 判断脊灰疫苗第2针是否接种
		if (t_map_2 != null) {
			// 第2针脊灰不为空
			if (Double.parseDouble((String) t_map_2.get("dif_mon")) < 1
					&& t_map_2.get("office").equals(office) && !(t_map_2.get("source").equals("3"))) {
				// 判断第2针接种时间是否在当月

				// 脊灰2针次是应种针次
				Y_BD_PV2_Map.put(childcode, "032");
				S_BD_PV2_Map.put(childcode, "032");
				// System.out.println(">>>脊灰疫苗2应种实种 >>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getPvBRe();
						ff.get(k).setPvBRe(++a);
						a = ff.get(k).getPvBSh();
						ff.get(k).setPvBSh(++a);
						break;
					}
				}
			} else {

				// System.out.println(">>>脊灰疫苗2已经接种很久了 >>>");
			}

		} else {
			
			Map<String, String> t_map_1 = (Map<String, String>) vacc_list.get("031");
			
			// 判断脊灰疫苗第1 针是否接种
			if (t_map_1 != null) {
				// 第一针脊灰不为空
				if (Double.parseDouble((String) t_map_1.get("dif_mon")) < 1
						&& t_map_1.get("office").equals(office) && !(t_map_1.get("source").equals("3"))) {
					// 判断第1针接种是否在当月

					// 脊灰1针次是应种针次
					Y_BD_PV1_Map.put(childcode, "031");
					S_BD_PV1_Map.put(childcode, "031");
					// System.out.println(">>>脊灰疫苗1应种实种>>>");
					for (int k = 0; k < ff.size(); k++) {
						if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
							
							int a = ff.get(k).getPvARe();
							ff.get(k).setPvARe(++a);
							a = ff.get(k).getPvASh();
							ff.get(k).setPvASh(++a);
							break;
						}
					}
				} else {
					if (vacc_yzrq.containsKey("032")  && situation.equals("1") && officeInfo.equals(office)) {
						// 第一针脊灰不为空 接种日期比较早

						// 脊灰2针次是应种针次
						Y_BD_PV2_Map.put(childcode, "032");
						// System.out.println(">>>脊灰疫苗2应种 >>>");
						for (int k = 0; k < ff.size(); k++) {
							if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
								
								int a = ff.get(k).getPvBSh();
								ff.get(k).setPvBSh(++a);
								break;
							}
						}
					}
				}
			} else {
				
					if (vacc_yzrq.containsKey("031")  && situation.equals("1") && officeInfo.equals(office)) {
						// 脊灰第1针次是应种
						Y_BD_PV1_Map.put(childcode, "031");
						// System.out.println(">>>脊灰疫苗1应种 >>>");
						for (int k = 0; k < ff.size(); k++) {
							if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
								
								int a = ff.get(k).getPvASh();
								ff.get(k).setPvASh(++a);
								break;
							}
						}
					}
			}
			
		}

	}

	// 脊灰第三针 4月龄
	public void do_PV_3( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area, String createDate, String office, String situation, String officeInfo){
		
		Map<String, String> t_map_3 = (Map<String, String>) vacc_list.get("033");
		
		// 判断脊灰第3针是否有接种纪录
		if (t_map_3 != null) {
			// 脊灰第3针已经有接种纪录
			if (Double.parseDouble((String) t_map_3.get("dif_mon")) < 1
					&& t_map_3.get("office").equals(office) && !(t_map_3.get("source").equals("3"))) {
				// 判断第3针接种时间是否在当月
				
				// 脊灰3针次是应种针次
				Y_BD_PV3_Map.put(childcode, "033");
				S_BD_PV3_Map.put(childcode, "033");
				// System.out.println(">>>脊灰疫苗3应种实种 >>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getPvCRe();
						ff.get(k).setPvCRe(++a);
						a = ff.get(k).getPvCSh();
						ff.get(k).setPvCSh(++a);
						break;
					}
				}
			} else {

				// System.out.println(">>>脊灰疫苗3接种很久了>>>");
			}
		} else {
			
			Map<String, String> t_map_2 = (Map<String, String>) vacc_list.get("032");
			
				// 没有替代 没有第三针，则判断脊灰疫苗第2针是否接种
				if (t_map_2 != null) {
					// 第2针脊灰不为空
					if (Double.parseDouble((String) t_map_2.get("dif_mon")) < 1
							&& t_map_2.get("office").equals(office) && !(t_map_2.get("source").equals("3"))) {
						// 判断第2针接种时间是否在当月

						// 脊灰2针次是应种针次
						Y_BD_PV2_Map.put(childcode, "032");
						S_BD_PV2_Map.put(childcode, "032");
						// System.out.println(">>>脊灰疫苗2应种实种 >>>");
						for (int k = 0; k < ff.size(); k++) {
							if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
								
								int a = ff.get(k).getPvBRe();
								ff.get(k).setPvBRe(++a);
								a = ff.get(k).getPvBSh();
								ff.get(k).setPvBSh(++a);
								break;
							}
						}
					} else {
						if (vacc_yzrq.containsKey("033")  && situation.equals("1") && officeInfo.equals(office)) {
							// 脊灰3针次是应种针次
							Y_BD_PV3_Map.put(childcode, "033");
							// System.out.println(">>>脊灰疫苗3应种 >>>");
							for (int k = 0; k < ff.size(); k++) {
								if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
									
									int a = ff.get(k).getPvCSh();
									ff.get(k).setPvCSh(++a);
									break;
								}
							}
						}
					}

				} else {
					
					Map<String, String> t_map_1 = (Map<String, String>) vacc_list.get("031");
					
						// 判断脊灰疫苗第1 针是否接种
						if (t_map_1 != null) {
							// 第一针脊灰不为空
							if (Double.parseDouble((String) t_map_1.get("dif_mon")) < 1
									&& t_map_1.get("office").equals(office) && !(t_map_1.get("source").equals("3"))) {
								// 判断第1针接种是否在当月

								// 脊灰1针次是应种针次
								Y_BD_PV1_Map.put(childcode, "031");
								S_BD_PV1_Map.put(childcode, "031");
								// System.out.println(">>>脊灰疫苗1应种实种>>>");
								for (int k = 0; k < ff.size(); k++) {
									if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
										
										int a = ff.get(k).getPvARe();
										ff.get(k).setPvARe(++a);
										a = ff.get(k).getPvASh();
										ff.get(k).setPvASh(++a);
										break;
									}
								}
							} else {
								if (vacc_yzrq.containsKey("032")  && situation.equals("1") && officeInfo.equals(office)) {
									// 第一针脊灰不为空 接种日期比较早
									// 脊灰2针次是应种针次
									Y_BD_PV2_Map.put(childcode, "032");
									// System.out.println(">>>脊灰疫苗2应种 >>>");
									for (int k = 0; k < ff.size(); k++) {
										if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
											
											int a = ff.get(k).getPvBSh();
											ff.get(k).setPvBSh(++a);
											break;
										}
									}
								} else {
									// System.out.println(">>>脊灰疫苗2不统计了 >>>");
								}
							}
						} else {
							
								if (vacc_yzrq.containsKey("031")  && situation.equals("1") && officeInfo.equals(office)) {
									// 脊灰第1针次是应种
									Y_BD_PV1_Map.put(childcode, "031");
									// System.out.println(">>>脊灰疫苗1应种 >>>");
									for (int k = 0; k < ff.size(); k++) {
										if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
											
											int a = ff.get(k).getPvASh();
											ff.get(k).setPvASh(++a);
											break;
										}
									}
								} else {
									// System.out.println(">>>脊灰疫苗1不统记了 >>>");
								}
							

						}
					

				}
			
		}

	}

	//// 脊灰 4针次
	public void do_PV_4( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area, String createDate, String office, String situation, String officeInfo){
		
		Map<String, String> t_map_4 = (Map<String, String>) vacc_list.get("034");

		if (t_map_4 != null) {
			// 脊灰疫苗第4针有接种记录

			if (Double.parseDouble((String) t_map_4.get("dif_mon")) < 1
					&& t_map_4.get("office").equals(office) && !(t_map_4.get("source").equals("3"))) {
				// 判断接种时间是否在当月
				Y_BD_PV4_Map.put(childcode, "034");
				S_BD_PV4_Map.put(childcode, "034");
				// System.out.println(">>>脊灰疫苗4应种实种 >>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getPvDRe();
						ff.get(k).setPvDRe(++a);
						a = ff.get(k).getPvDSh();
						ff.get(k).setPvDSh(++a);
						break;
					}
				}

			} else {
				// System.out.println(">>>脊灰疫苗4接种很久了>>>");
			}
		} else {
			
			Map<String, String> t_map_3 = (Map<String, String>) vacc_list.get("033");
			
			// 判断脊灰第3针是否有接种纪录
			if (t_map_3 != null) {
				// 脊灰第3针已经有接种纪录
				if (Double.parseDouble((String) t_map_3.get("dif_mon")) < 1
						&& t_map_3.get("office").equals(office) && !(t_map_3.get("source").equals("3"))) {
					// 判断第3针接种时间是否在当月

					// 脊灰3针次是应种针次
					Y_BD_PV3_Map.put(childcode, "033");
					S_BD_PV3_Map.put(childcode, "033");
					// System.out.println(">>>脊灰疫苗3应种实种 >>>");
					for (int k = 0; k < ff.size(); k++) {
						if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
							
							int a = ff.get(k).getPvCRe();
							ff.get(k).setPvCRe(++a);
							a = ff.get(k).getPvCSh();
							ff.get(k).setPvCSh(++a);
							break;
						}
					}
				} else {
					if (vacc_yzrq.containsKey("034")  && situation.equals("1") && officeInfo.equals(office)) {
						// 脊灰第4针次是应种
						Y_BD_PV4_Map.put(childcode, "034");
						// System.out.println(">>>脊灰疫苗4应种>>>");
						for (int k = 0; k < ff.size(); k++) {
							if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
								
								int a = ff.get(k).getPvDSh();
								ff.get(k).setPvDSh(++a);
								break;
							}
						}
					} else {
						// System.out.println("不做统计了");
					}
				}
			} else {
				
				Map<String, String> t_map_2 = (Map<String, String>) vacc_list.get("032");
				
					// 判断脊灰疫苗第2针是否接种
					if (t_map_2 != null) {
						// 第2针脊灰不为空
						if (Double.parseDouble((String) t_map_2.get("dif_mon")) < 1
								&& t_map_2.get("office").equals(office) && !(t_map_2.get("source").equals("3"))) {
							// 判断第2针接种时间是否在当月

							// 脊灰2针次是应种针次
							Y_BD_PV2_Map.put(childcode, "032");
							S_BD_PV2_Map.put(childcode, "032");
							// System.out.println(">>>脊灰疫苗2应种实种 >>>");
							for (int k = 0; k < ff.size(); k++) {
								if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
									
									int a = ff.get(k).getPvBRe();
									ff.get(k).setPvBRe(++a);
									a = ff.get(k).getPvBSh();
									ff.get(k).setPvBSh(++a);
									break;
								}
							}
						} else {
							if (vacc_yzrq.containsKey("033")  && situation.equals("1") && officeInfo.equals(office)) {
								// 脊灰3针次是应种针次
								Y_BD_PV3_Map.put(childcode, "033");
								// System.out.println(">>>脊灰疫苗3应种 >>>");
								for (int k = 0; k < ff.size(); k++) {
									if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
										
										int a = ff.get(k).getPvCSh();
										ff.get(k).setPvCSh(++a);
										break;
									}
								}
							} else {
								// System.out.println("不做统计了");
							}
						}

					} else {
						
						Map<String, String> t_map_1 = (Map<String, String>) vacc_list.get("031");
						
							// 判断脊灰疫苗第1 针是否接种
							if (t_map_1 != null) {
								// 第一针脊灰不为空
								if (Double.parseDouble((String) t_map_1.get("dif_mon")) < 1
										&& t_map_1.get("office").equals(office) && !(t_map_1.get("source").equals("3"))) {
									// 判断第1针接种是否在当月

									// 脊灰1针次是应种针次
									Y_BD_PV1_Map.put(childcode, "031");
									S_BD_PV1_Map.put(childcode, "031");
									// System.out.println(">>>脊灰疫苗1应种实种>>>");
									for (int k = 0; k < ff.size(); k++) {
										if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
											
											int a = ff.get(k).getPvARe();
											ff.get(k).setPvARe(++a);
											a = ff.get(k).getPvASh();
											ff.get(k).setPvASh(++a);
											break;
										}
									}
								} else {
									if (vacc_yzrq.containsKey("032")  && situation.equals("1") && officeInfo.equals(office)) {
										// 第一针脊灰不为空 接种日期比较早

										// 脊灰2针次是应种针次
										Y_BD_PV2_Map.put(childcode, "032");
										// System.out.println(">>>脊灰疫苗2应种
										// >>>");
										for (int k = 0; k < ff.size(); k++) {
											if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
												
												int a = ff.get(k).getPvBSh();
												ff.get(k).setPvBSh(++a);
												break;
											}
										}
									} else {
										// System.out.println("不做统计了");
									}
								}
							} else {
								
									if (vacc_yzrq.containsKey("031")  && situation.equals("1") && officeInfo.equals(office)) {
										// 脊灰第1针次是应种
										Y_BD_PV1_Map.put(childcode, "031");
										// System.out.println(">>>脊灰疫苗1应种
										for (int k = 0; k < ff.size(); k++) {
											if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
												
												int a = ff.get(k).getPvASh();
												ff.get(k).setPvASh(++a);
												break;
											}
										}
									} else {
										// System.out.println("不做统计了");
									}
								
							}
						
					}
				
			}
			
		}
	}
	
	public void do_PV_4_2( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area, String createDate, String office, String situation, String officeInfo){
		
		Map<String, String> t_map_4 = (Map<String, String>) vacc_list.get("034");

		if (t_map_4 != null) {
			// 脊灰疫苗第4针有接种记录

			if (Double.parseDouble((String) t_map_4.get("dif_mon")) < 1
					&& t_map_4.get("office").equals(office) && !(t_map_4.get("source").equals("3"))) {
				// 判断接种时间是否在当月
				Y_BD_PV4_Map.put(childcode, "034");
				S_BD_PV4_Map.put(childcode, "034");
				// System.out.println(">>>脊灰疫苗4应种实种 >>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getPvDRe();
						ff.get(k).setPvDRe(++a);
						a = ff.get(k).getPvDSh();
						ff.get(k).setPvDSh(++a);
						break;
					}
				}

			} else {
				// System.out.println(">>>脊灰疫苗4接种很久了>>>");
			}
		}
	}

	////

	// 百白破1
	public void do_DTP_1( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area, String createDate, String office, String situation, String officeInfo){
		
		Map<String, String> t_map_1 = (Map<String, String>) vacc_list.get("041");

		// 判断百白破疫苗第1 针是否接种
		if (t_map_1 != null) {
			// 第一针百白破不为空
			if (Double.parseDouble((String) t_map_1.get("dif_mon")) < 1
					&& t_map_1.get("office").equals(office) && !(t_map_1.get("source").equals("3"))) {
				// 判断第1针接种是否在当月

				// 百白破1针次是应种针次
				Y_BD_DTP1_Map.put(childcode, "041");
				S_BD_DTP1_Map.put(childcode, "041");
				
				// System.out.println(">>>百白破疫苗1应种实种>>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getDtpARe();
						ff.get(k).setDtpARe(++a);
						a = ff.get(k).getDtpASh();
						ff.get(k).setDtpASh(++a);
						break;
					}
				}
			} else {

				// System.out.println(">>>百白破疫苗1已经很久了>>>");

			}
		} else {
			
				if (vacc_yzrq.containsKey("041")  && situation.equals("1") && officeInfo.equals(office)) {
					// 第一针百白破为空
					// 百白破第1针次是应种
					Y_BD_DTP1_Map.put(childcode, "041");
					
					// System.out.println(">>>百白破疫苗1应种 >>>");
					for (int k = 0; k < ff.size(); k++) {
						if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {

							int a = ff.get(k).getDtpASh();
							ff.get(k).setDtpASh(++a);
							break;
						}
					}
				} else {
					// System.out.println("不做统计了");
				}
			
		}

	}

	// 百白破2
	public void do_DTP_2( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area, String createDate, String office, String situation, String officeInfo){
		
		Map<String, String> t_map_2 = (Map<String, String>) vacc_list.get("042");

		// 判断百白破疫苗第2针是否接种
		if (t_map_2 != null) {
			// 第2针百白破不为空
			if (Double.parseDouble((String) t_map_2.get("dif_mon")) < 1
					&& t_map_2.get("office").equals(office) && !(t_map_2.get("source").equals("3"))) {
				// 判断第2针接种时间是否在当月

				// 百白破2针次是应种针次
				Y_BD_DTP2_Map.put(childcode, "042");
				S_BD_DTP2_Map.put(childcode, "042");
				// System.out.println(">>>百白破疫苗2应种 实种>>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getDtpBRe();
						ff.get(k).setDtpBRe(++a);
						a = ff.get(k).getDtpBSh();
						ff.get(k).setDtpBSh(++a);
						break;
					}
				}
			} else {

				// System.out.println(">>>百白破疫苗2 很早以前就接种了 >>>");
			}

		} else {
			
			Map<String, String> t_map_1 = (Map<String, String>) vacc_list.get("041");
			
				// 判断百白破疫苗第1 针是否接种
				if (t_map_1 != null) {
					// 第一针百白破不为空
					if (Double.parseDouble((String) t_map_1.get("dif_mon")) < 1
							&& t_map_1.get("office").equals(office) && !(t_map_1.get("source").equals("3"))) {
						// 判断第1针接种是否在当月

						// 百白破1针次是应种针次
						Y_BD_DTP1_Map.put(childcode, "041");
						S_BD_DTP1_Map.put(childcode, "041");
						
						// System.out.println(">>>百白破疫苗1应种实种>>>");
						for (int k = 0; k < ff.size(); k++) {
							if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
								
								int a = ff.get(k).getDtpARe();
								ff.get(k).setDtpARe(++a);
								a = ff.get(k).getDtpASh();
								ff.get(k).setDtpASh(++a);
								break;
							}
						}
					} else {
						if (vacc_yzrq.containsKey("042")  && situation.equals("1") && officeInfo.equals(office)) {
							// 百白破2针次是应种针次
							Y_BD_DTP2_Map.put(childcode, "042");
							// System.out.println(">>>百白破疫苗2应种 >>>");
							for (int k = 0; k < ff.size(); k++) {
								if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
									
									int a = ff.get(k).getDtpBSh();
									ff.get(k).setDtpBSh(++a);
									break;
								}
							}
						} else {
							// System.out.println("不做统计了");
						}
					}
				} else {
					
						if (vacc_yzrq.containsKey("041")  && situation.equals("1") && officeInfo.equals(office)) {
							// 第一针百白破为空
							// 百白破第1针次是应种
							Y_BD_DTP1_Map.put(childcode, "041");
							
							// System.out.println(">>>百白破疫苗1应种 >>>");
							for (int k = 0; k < ff.size(); k++) {
								if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
									
									int a = ff.get(k).getDtpASh();
									ff.get(k).setDtpASh(++a);
									break;
								}
							}
						} else {
							// System.out.println("不做统计了");
						}
					

				}
			
		}

	}

	// 百白破3
	public void do_DTP_3( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area, String createDate, String office, String situation, String officeInfo){
		
		Map<String, String> t_map_3 = (Map<String, String>) vacc_list.get("043");

		// 判断百白破第3针是否有接种纪录
		if (t_map_3 != null) {
			// 百白破第3针已经有接种纪录
			if (Double.parseDouble((String) t_map_3.get("dif_mon")) < 1
					&& t_map_3.get("office").equals(office) && !(t_map_3.get("source").equals("3"))) {
				// 判断第3针接种时间是否在当月

				// 百白破3针次是应种针次
				Y_BD_DTP3_Map.put(childcode, "043");
				S_BD_DTP3_Map.put(childcode, "043");

				// System.out.println(">>>百白破疫苗3应种实种 >>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getDtpCRe();
						ff.get(k).setDtpCRe(++a);
						a = ff.get(k).getDtpCSh();
						ff.get(k).setDtpCSh(++a);
						break;
					}
				}
			} else {
				// System.out.println(">>>百白破疫苗3很早就接种了>>>");
			}
		} else {
			
			Map<String, String> t_map_2 = (Map<String, String>) vacc_list.get("042");
			
				// 判断百白破疫苗第2针是否接种
				if (t_map_2 != null) {
					// 第2针百白破不为空
					if (Double.parseDouble((String) t_map_2.get("dif_mon")) < 1
							&& t_map_2.get("office").equals(office) && !(t_map_2.get("source").equals("3"))) {
						// 判断第2针接种时间是否在当月

						// 百白破2针次是应种针次
						Y_BD_DTP2_Map.put(childcode, "042");
						S_BD_DTP2_Map.put(childcode, "042");

						// System.out.println(">>>百白破疫苗2应种 实种>>>");
						for (int k = 0; k < ff.size(); k++) {
							if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
								
								int a = ff.get(k).getDtpBRe();
								ff.get(k).setDtpBRe(++a);
								a = ff.get(k).getDtpBSh();
								ff.get(k).setDtpBSh(++a);
								break;
							}
						}
					} else {
						if (vacc_yzrq.containsKey("043")  && situation.equals("1") && officeInfo.equals(office)) {
							// 百白破3针次是应种针次
							Y_BD_DTP3_Map.put(childcode, "043");
							// System.out.println(">>>百白破疫苗3应种 >>>");
							for (int k = 0; k < ff.size(); k++) {
								if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
									
									int a = ff.get(k).getDtpCSh();
									ff.get(k).setDtpCSh(++a);
									break;
								}
							}
						} else {
							// System.out.println("不做统计了");
						}
					}

				} else {
					
					Map<String, String> t_map_1 = (Map<String, String>) vacc_list.get("041");
					
						// 判断百白破疫苗第1 针是否接种
						if (t_map_1 != null) {
							// 第一针百白破不为空
							if (Double.parseDouble((String) t_map_1.get("dif_mon")) < 1
									&& t_map_1.get("office").equals(office) && !(t_map_1.get("source").equals("3"))) {
								// 判断第1针接种是否在当月

								// 百白破1针次是应种针次
								Y_BD_DTP1_Map.put(childcode, "041");
								S_BD_DTP1_Map.put(childcode, "041");
								
								// System.out.println(">>>百白破疫苗1应种实种>>>");
								for (int k = 0; k < ff.size(); k++) {
									if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
										
										int a = ff.get(k).getDtpARe();
										ff.get(k).setDtpARe(++a);
										a = ff.get(k).getDtpASh();
										ff.get(k).setDtpASh(++a);
										break;
									}
								}
							} else {
								if (vacc_yzrq.containsKey("042")  && situation.equals("1") && officeInfo.equals(office)) {
									// 百白破2针次是应种针次
									Y_BD_DTP2_Map.put(childcode, "042");
									// System.out.println(">>>百白破疫苗2应种 >>>");
									for (int k = 0; k < ff.size(); k++) {
										if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
											
											int a = ff.get(k).getDtpBSh();
											ff.get(k).setDtpBSh(++a);
											break;
										}
									}
								} else {
									// System.out.println("不做统计了");
								}
							}
						} else {
							
								if (vacc_yzrq.containsKey("041")  && situation.equals("1") && officeInfo.equals(office)) {
									// 第一针百白破为空
									// 百白破第1针次是应种
									Y_BD_DTP1_Map.put(childcode, "041");

									// System.out.println(">>>百白破疫苗1应种 >>>");
									for (int k = 0; k < ff.size(); k++) {
										if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
											
											int a = ff.get(k).getDtpASh();
											ff.get(k).setDtpASh(++a);
											break;
										}
									}
								} else {
									// System.out.println("不做统计了");
								}
							
						}
					
				}
			
		}

	}

	// 百白破4
	public void do_DTP_4( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area, String createDate, String office, String situation, String officeInfo){
		
		Map<String, String> t_map_4 = (Map<String, String>) vacc_list.get("044");

		if (t_map_4 != null) {
			// 百白破疫苗第4针有接种记录
			if (Double.parseDouble((String) t_map_4.get("dif_mon")) < 1
					&& t_map_4.get("office").equals(office) && !(t_map_4.get("source").equals("3"))) {
				// 判断接种时间是否在当月
				Y_BD_DTP4_Map.put(childcode, "044");
				S_BD_DTP4_Map.put(childcode, "044");

				// System.out.println(">>>百白破疫苗4应种实种 >>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getDtpDRe();
						ff.get(k).setDtpDRe(++a);
						a = ff.get(k).getDtpDSh();
						ff.get(k).setDtpDSh(++a);
						break;
					}
				}
			} else {
				// System.out.println(">>>百白破疫苗4很早就接种了 >>>");
			}
		} else {
			
			Map<String, String> t_map_3 = (Map<String, String>) vacc_list.get("043");
			
				// 判断百白破第3针是否有接种纪录
				if (t_map_3 != null) {
					// 百白破第3针已经有接种纪录
					if (Double.parseDouble((String) t_map_3.get("dif_mon")) < 1
							&& t_map_3.get("office").equals(office) && !(t_map_3.get("source").equals("3"))) {
						// 判断第3针接种时间是否在当月

						// 百白破3针次是应种针次
						Y_BD_DTP3_Map.put(childcode, "043");
						S_BD_DTP3_Map.put(childcode, "043");
						// System.out.println(">>>百白破疫苗3应种实种 >>>");
						for (int k = 0; k < ff.size(); k++) {
							if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
								
								int a = ff.get(k).getDtpCRe();
								ff.get(k).setDtpCRe(++a);
								a = ff.get(k).getDtpCSh();
								ff.get(k).setDtpCSh(++a);
								break;
							}
						}
					} else {
						if (vacc_yzrq.containsKey("044")  && situation.equals("1") && officeInfo.equals(office)) {
							if (Double.parseDouble((String) t_map_3.get("dif_mon")) > 6) {
								// 百白破第4针次是应种
								Y_BD_DTP4_Map.put(childcode, "044");
								// System.out.println(">>>百白破疫苗4应种>>>");
								for (int k = 0; k < ff.size(); k++) {
									if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
										
										int a = ff.get(k).getDtpDSh();
										ff.get(k).setDtpDSh(++a);
										break;
									}else{
										//TODO:将应种值计入默认社区
									}
								}
							} else {
								// System.out.println(">>>百白破疫苗4未到间隔>>>");
							}
						} else {
							// System.out.println("不做统计了");
						}

					}
				} else {
					
					Map<String, String> t_map_2 = (Map<String, String>) vacc_list.get("042");
					
						// 判断百白破疫苗第2针是否接种
						if (t_map_2 != null) {
							// 第2针百白破不为空
							if (Double.parseDouble((String) t_map_2.get("dif_mon")) < 1
									&& t_map_2.get("office").equals(office) && !(t_map_2.get("source").equals("3"))) {
								// 判断第2针接种时间是否在当月

								// 百白破2针次是应种针次
								Y_BD_DTP2_Map.put(childcode, "042");
								S_BD_DTP2_Map.put(childcode, "042");
								// System.out.println(">>>百白破疫苗2应种实种 >>>");
								for (int k = 0; k < ff.size(); k++) {
									if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
										
										int a = ff.get(k).getDtpBRe();
										ff.get(k).setDtpBRe(++a);
										a = ff.get(k).getDtpBSh();
										ff.get(k).setDtpBSh(++a);
										break;
									}
								}
							} else {
								if (vacc_yzrq.containsKey("043")  && situation.equals("1") && officeInfo.equals(office)) {
									// 百白破3针次是应种针次
									Y_BD_DTP3_Map.put(childcode, "043");

									// System.out.println(">>>百白破疫苗3应种 >>>");
									for (int k = 0; k < ff.size(); k++) {
										if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
											
											int a = ff.get(k).getDtpCSh();
											ff.get(k).setDtpCSh(++a);
											break;
										}
									}
								} else {
									// System.out.println("不做统计了");
								}
							}

						} else {
							
							Map<String, String> t_map_1 = (Map<String, String>) vacc_list.get("041");
							
								// 判断百白破疫苗第1 针是否接种
								if (t_map_1 != null) {
									// 第一针百白破不为空
									if (Double.parseDouble((String) t_map_1.get("dif_mon")) < 1
											&& t_map_1.get("office").equals(office) && !(t_map_1.get("source").equals("3"))) {
										// 判断第1针接种是否在当月

										// 百白破1针次是应种针次
										Y_BD_DTP1_Map.put(childcode, "041");
										S_BD_DTP1_Map.put(childcode, "041");

										// System.out.println(">>>百白破疫苗1应种实种>>>");
										for (int k = 0; k < ff.size(); k++) {
											if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
												
												int a = ff.get(k).getDtpARe();
												ff.get(k).setDtpARe(++a);
												a = ff.get(k).getDtpASh();
												ff.get(k).setDtpASh(++a);
												break;
											}
										}
									} else {
										if (vacc_yzrq.containsKey("042")  && situation.equals("1") && officeInfo.equals(office)) {

											// 百白破2针次是应种针次
											Y_BD_DTP2_Map.put(childcode, "042");

											// System.out.println(">>>百白破疫苗2应种
											// >>>");
											for (int k = 0; k < ff.size(); k++) {
												if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
													
													int a = ff.get(k).getDtpBSh();
													ff.get(k).setDtpBSh(++a);
													break;
												}
											}
										} else {
											// System.out.println("不做统计了");
										}
									}
								} else {
									
										if (vacc_yzrq.containsKey("041")  && situation.equals("1") && officeInfo.equals(office)) {
											// 第一针百白破为空
											// 百白破第1针次是应种
											Y_BD_DTP1_Map.put(childcode, "041");

											// System.out.println(">>>百白破疫苗1应种
											// >>>");
											for (int k = 0; k < ff.size(); k++) {
												if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
													
													int a = ff.get(k).getDtpASh();
													ff.get(k).setDtpASh(++a);
													break;
												}
											}
										} else {
											// System.out.println("不做统计了");
										}
									
								}
							
						}
					
				}
			
		}
	}
	
	

	/////////////////////

	// A+C群流脑结合1
	public void do_MENA_1( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area, String createDate, String office, String situation, String officeInfo){
		
		Map<String, String> t_map_1 = (Map<String, String>) vacc_list.get("871");

		// 判断A+C群流脑结合疫苗第1针是否有接种纪录
		if (t_map_1 != null) {
			// A+C群流脑结合疫苗第1针已经有接种纪录
			if (Double.parseDouble((String) t_map_1.get("dif_mon")) < 1
					&& t_map_1.get("office").equals(office) && !(t_map_1.get("source").equals("3"))) {
				// 判断第1针接种时间是否在当月

				// A+C群流脑结合疫苗第1针次是应种针次
				Y_BD_MenA1_Map.put(childcode, "871");
				S_BD_MenA1_Map.put(childcode, "871");
				// System.out.println(">>>A+C群流脑结合疫苗1应种实种 >>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getMenaARe();
						ff.get(k).setMenaARe(++a);
						a = ff.get(k).getMenaASh();
						ff.get(k).setMenaASh(++a);
						break;
					}
				}
			} else {
				// A+C群流脑结合疫苗第2针次是应种

				// System.out.println(">>>A+C群流脑结合疫苗1很早就接种了>>>");
			}
		} else {			
				
			if (vacc_yzrq.containsKey("871")  && situation.equals("1") && officeInfo.equals(office)) {
				// A+C群流脑结合疫苗1应种
				Y_BD_MenA1_Map.put(childcode, "871");

				// System.out.println(">>>A+C群流脑结合疫苗1应种>>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getMenaASh();
						ff.get(k).setMenaASh(++a);
						break;
					}
				}
			} else {
				// System.out.println("不做统计了");
			}				
			
		}

	}
	
	/**
	 * A+C群流脑结合1 对AC-Hib联合疫苗拆解的情况做特殊处理,判断月龄:2-6月<br>
	 * 此情况只判断由ACHib拆解而来,如果是拆解实种：实种+1、应种+1,如果是拆解的应种未种则不计入应种和实种.
	 * @author Jack
	 * @date 2018年2月2日 下午5:47:09
	 * @description 
	 * @param vacc_list
	 * @param childcode
	 * @param vacc_yzrq
	 * @param reside
	 * @param area
	 * @param createDate
	 * @param office
	 * @param situation
	 * @param officeInfo
	 *
	 */
	public void do_MENA_1_Special( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area, String createDate, String office, String situation, String officeInfo){
		
		Map<String, String> t_map_1 = (Map<String, String>) vacc_list.get("871");

		// 判断A+C群流脑结合疫苗第1针是否有接种纪录
		if (t_map_1 != null) {
			// A+C群流脑结合疫苗第1针已经有接种纪录
			if (Double.parseDouble((String) t_map_1.get("dif_mon")) < 1
					&& t_map_1.get("office").equals(office) && !(t_map_1.get("source").equals("3"))) {
				// 判断第1针接种时间是否在当月

				// A+C群流脑结合疫苗第1针次是应种针次
				Y_BD_MenA1_Map.put(childcode, "871");
				S_BD_MenA1_Map.put(childcode, "871");
				// System.out.println(">>>A+C群流脑结合疫苗1应种实种 >>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getMenaARe();
						ff.get(k).setMenaARe(++a);
						a = ff.get(k).getMenaASh();
						ff.get(k).setMenaASh(++a);
						break;
					}
				}
			} else {
				// A+C群流脑结合疫苗第2针次是应种

				// System.out.println(">>>A+C群流脑结合疫苗1很早就接种了>>>");
			}
		}

	}

	// A+C群流脑结合2
	public void do_MENA_2( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area, String createDate, String office, String situation, String officeInfo){
		
		Map<String, String> t_map_2 = (Map<String, String>) vacc_list.get("872");

		if (t_map_2 != null) {
			// A+C群流脑结合疫苗第2针有接种记录

			if (Double.parseDouble((String) t_map_2.get("dif_mon")) < 1
					&& t_map_2.get("office").equals(office) && !(t_map_2.get("source").equals("3"))) {
				// 判断接种时间是否在当月
				Y_BD_MenA2_Map.put(childcode, "872");
				S_BD_MenA2_Map.put(childcode, "872");

				// System.out.println(">>>A+C群流脑结合疫苗2应种实种 >>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getMenaBRe();
						ff.get(k).setMenaBRe(++a);
						a = ff.get(k).getMenaBSh();
						ff.get(k).setMenaBSh(++a);
						break;
					}
				}
			} else {
				// System.out.println(">>>A+C群流脑结合疫苗2很早就接种了 >>>");
			}
		} else {
			
			Map<String, String> t_map_1 = (Map<String, String>) vacc_list.get("871");
			
			if (t_map_1 != null) {
				// A+C群流脑疫苗第1针已经有接种纪录
				if (Double.parseDouble((String) t_map_1.get("dif_mon")) < 1
						&& t_map_1.get("office").equals(office) && !(t_map_1.get("source").equals("3"))) {
					// 判断第1针接种时间是否在当月

					// A+C群流脑结合疫苗第1针次是应种针次
					Y_BD_MenA1_Map.put(childcode, "871");
					S_BD_MenA1_Map.put(childcode, "871");
					// System.out.println(">>>A+C群流脑结合疫苗1应种实种
					// >>>");
					for (int k = 0; k < ff.size(); k++) {
						if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
							
							int a = ff.get(k).getMenaARe();
							ff.get(k).setMenaARe(++a);
							a = ff.get(k).getMenaASh();
							ff.get(k).setMenaASh(++a);
							break;
						}
					}
				} else {
					if (vacc_yzrq.containsKey("872")  && situation.equals("1") && officeInfo.equals(office)) {
						// A+C群流脑结合疫苗第2针次是应种
						Y_BD_MenA2_Map.put(childcode, "872");

						// System.out.println(">>>A+C群流脑结合疫苗2应种>>>");
						for (int k = 0; k < ff.size(); k++) {
							if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
								
								int a = ff.get(k).getMenaBSh();
								ff.get(k).setMenaBSh(++a);
								break;
							}
						}
					} else {
						// System.out.println("不做统计了");
					}
				}
			} else {
				if (vacc_yzrq.containsKey("871")  && situation.equals("1") && officeInfo.equals(office)) {
					// A+C群流脑结合疫苗1应种
					Y_BD_MenA1_Map.put(childcode, "871");

					// System.out.println(">>>A+C群流脑结合疫苗1应种>>>");
					for (int k = 0; k < ff.size(); k++) {
						if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
							
							int a = ff.get(k).getMenaASh();
							ff.get(k).setMenaASh(++a);
							break;
						}
					}
				} else {
					// System.out.println("不做统计了");
				}
			}
		}
	}
	////////////////////////////////////

	// A群流脑多糖1
	public void do_MPSVA_1( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area, String createDate, String office, String situation, String officeInfo){
		
		Map<String, String> t_map_1 = (Map<String, String>) vacc_list.get("161");
		
		// 判断A群流脑多糖疫苗第1针是否有接种纪录
		if (t_map_1 != null) {
			// A群流脑多糖疫苗第1针已经有接种纪录
			if (Double.parseDouble((String) t_map_1.get("dif_mon")) < 1
					&& t_map_1.get("office").equals(office) && !(t_map_1.get("source").equals("3"))) {
				// 判断第1针接种时间是否在当月

				// A群流脑多糖疫苗第1针次是应种针次
				Y_BD_MPSV_A1_Map.put(childcode, "161");
				S_BD_MPSV_A1_Map.put(childcode, "161");
				
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
					}
				}
				
				// System.out.println(">>>A群流脑多糖疫苗1应种实种 >>>");

			} else {
				// System.out.println(">>>A群流脑多糖疫苗1已经接种很久了>>>");
			}
		} else {
			
				
			if (vacc_yzrq.containsKey("161") && situation.equals("1") && officeInfo.equals(office)) {
				// A群流脑多糖疫苗1应种
				Y_BD_MPSV_A1_Map.put(childcode, "161");
				
				
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
					}
				}
				

				// System.out.println(">>>A群流脑多糖疫苗1应种>>>");
			} else {
				// System.out.println("不做统计了");
			}
				

			
		}

	}

	// A群流脑多糖2(未做统计)
	public void do_MPSVA_2( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area, String createDate, String office, String situation, String officeInfo){
		
		Map<String, String> t_map_2 = (Map<String, String>) vacc_list.get("162");

		if (t_map_2 != null) {
			// A群流脑多糖疫苗第2针有接种记录

			if (Double.parseDouble((String) t_map_2.get("dif_mon")) < 1
					&& t_map_2.get("office").equals(office) && !(t_map_2.get("source").equals("3"))) {
				// 判断接种时间是否在当月
				Y_BD_MPSV_A2_Map.put(childcode, "162");
				S_BD_MPSV_A2_Map.put(childcode, "162");
				
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
				
					}
				}
				
				
				// System.out.println(">>>A群流脑多糖疫苗2应种实种 >>>");
			} else {
				// System.out.println(">>>A群流脑多糖疫苗2很早就接种了 >>>");

			}
		} else {
			
			Map<String, String> t_map_1 = (Map<String, String>) vacc_list.get("161");
			
				
			if (t_map_1 != null) {
				if (Double.parseDouble((String) t_map_1.get("dif_mon")) < 1
						&& t_map_1.get("office").equals(office) && !(t_map_1.get("source").equals("3"))) {
					// 判断第1针接种时间是否在当月

					// A群流脑多糖疫苗第1针次是应种针次
					Y_BD_MPSV_A1_Map.put(childcode, "161");
					S_BD_MPSV_A1_Map.put(childcode, "161");
					
					
					for (int k = 0; k < ff.size(); k++) {
						if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
							
						}
					}
					
					// System.out.println(">>>A群流脑多糖疫苗1应种实种>>>");
				} else {
					if (vacc_yzrq.containsKey("162")  && situation.equals("1") && officeInfo.equals(office)) {
						if (Double.parseDouble((String) t_map_1.get("dif_mon")) > 3) {
							Y_BD_MPSV_A2_Map.put(childcode, "162");
							
							for (int k = 0; k < ff.size(); k++) {
								if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
									
								}
							}
							
							// System.out.println(">>>A群流脑多糖疫苗2应种>>>");
						} else {
							// System.out.println(">>>A群流脑多糖疫苗2未到间隔>>>");
						}
					} else {
						// System.out.println("不做统计了");
					}
				}
			} else {
				
					
				if (vacc_yzrq.containsKey("161")  && situation.equals("1") && officeInfo.equals(office)) {
					// A群流脑多糖疫苗1应种
					Y_BD_MPSV_A1_Map.put(childcode, "161");
					
					for (int k = 0; k < ff.size(); k++) {
						if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
							
						}
					}
					

					// System.out.println(">>>A群流脑多糖疫苗1应种>>>");
				} else {
					// System.out.println("不做统计了");
				}
					
				

			}
				
			
		}
	}

	//////////////////////////////

	// 麻风1
	public void do_MR_1( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area, String createDate, String office, String situation, String officeInfo){
		
		Map<String, String> t_map_1 = (Map<String, String>) vacc_list.get("141");

		if (t_map_1 == null) {
			if (vacc_yzrq.containsKey("141")  && situation.equals("1") && officeInfo.equals(office)) {
				// 麻风
				Y_BD_MR1_Map.put(childcode, vacc_list.get("141"));

				// System.out.println("麻风1应种");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getMrASh();
						ff.get(k).setMrASh(++a);
						break;
					}
				}
			} else {
				// System.out.println("不做统计了");
			}
		} else {

			if (Double.parseDouble((String) t_map_1.get("dif_mon")) < 1
					&& t_map_1.get("office").equals(office) && !(t_map_1.get("source").equals("3"))) {
				// 判断接种时间是否在当月
				Y_BD_MR1_Map.put(childcode, "141");
				S_BD_MR1_Map.put(childcode, "141");

				// System.out.println(">>>麻风疫苗1应种实种 >>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getMrARe();
						ff.get(k).setMrARe(++a);
						a = ff.get(k).getMrASh();
						ff.get(k).setMrASh(++a);
						break;
					}
				}

			}
		}
	}

	//////////////////

	// 乙脑减毒活疫苗1
	public void do_JEL_1( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area, String createDate, String office, String situation, String officeInfo){
		
		Map<String, String> t_map_1 = (Map<String, String>) vacc_list.get("841");

		// 判断乙脑减毒活疫苗第1针是否有接种纪录
		if (t_map_1 != null) {
			// 乙脑减毒活疫苗第1针已经有接种纪录
			if (Double.parseDouble((String) t_map_1.get("dif_mon")) < 1
					&& t_map_1.get("office").equals(office) && !(t_map_1.get("source").equals("3"))) {
				// 判断第1针接种时间是否在当月

				// 乙脑减毒活疫苗第1针次是应种针次
				Y_BD_JE_L1_Map.put(childcode, "841");
				S_BD_JE_L1_Map.put(childcode, "841");

				// System.out.println(">>>乙脑减毒活疫苗1应种实种 >>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getJelARe();
						ff.get(k).setJelARe(++a);
						a = ff.get(k).getJelASh();
						ff.get(k).setJelASh(++a);
						break;
					}
				}
			} else {
				// System.out.println(">>>乙脑减毒活疫苗1已经接种很久了>>>");
			}
		} else {
			
			if (vacc_yzrq.containsKey("841")  && situation.equals("1") && officeInfo.equals(office)) {
				// 乙脑减毒活疫苗1应种
				Y_BD_JE_L1_Map.put(childcode, "841");
				// System.out.println(">>>乙脑减毒活疫苗1应种>>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getJelASh();
						ff.get(k).setJelASh(++a);
						break;
					}
				}
			} else {
				// System.out.println("不做统计了");
			}
			
		}

	}

	// 乙脑减毒活疫苗2
	public void do_JEL_2( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area, String createDate, String office, String situation, String officeInfo){
		
		Map<String, String> t_map_2 = (Map<String, String>) vacc_list.get("842");

		if (t_map_2 != null) {
			// 乙脑减毒活疫苗第2针有接种记录

			if (Double.parseDouble((String) t_map_2.get("dif_mon")) < 1
					&& t_map_2.get("office").equals(office) && !(t_map_2.get("source").equals("3"))) {
				// 判断接种时间是否在当月
				Y_BD_JE_L2_Map.put(childcode, "842");
				S_BD_JE_L2_Map.put(childcode, "842");
				// System.out.println(">>>乙脑减毒活疫苗2应种实种 >>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getJelBRe();
						ff.get(k).setJelBRe(++a);
						a = ff.get(k).getJelBSh();
						ff.get(k).setJelBSh(++a);
						break;
					}
				}
			} else {
				// System.out.println(">>>乙脑减毒活疫苗2已经接种很久了>>>");
			}
		} else {
			
			Map<String, String> t_map_1 = (Map<String, String>) vacc_list.get("841");
			
				// 判断乙脑减毒活疫苗第1针是否有接种纪录
				if (t_map_1 != null) {
					// 乙脑减毒活疫苗第1针已经有接种纪录
					if (Double.parseDouble((String) t_map_1.get("dif_mon")) < 1
							&& t_map_1.get("office").equals(office) && !(t_map_1.get("source").equals("3"))) {
						// 判断第1针接种时间是否在当月

						// 乙脑减毒活疫苗第1针次是应种针次
						Y_BD_JE_L1_Map.put(childcode, "841");
						S_BD_JE_L1_Map.put(childcode, "841");
						// System.out.println(">>>乙脑减毒活疫苗1应种实种 >>>");
						for (int k = 0; k < ff.size(); k++) {
							if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
								
								int a = ff.get(k).getJelARe();
								ff.get(k).setJelARe(++a);
								a = ff.get(k).getJelASh();
								ff.get(k).setJelASh(++a);
								break;
							}
						}
					} else {
						if (vacc_yzrq.containsKey("842")  && situation.equals("1") && officeInfo.equals(office)) {
							if (Double.parseDouble((String) t_map_1.get("dif_mon")) > 12) {
								// 判断第1针接种时间是否在当月

								// 乙脑减毒活疫苗第2针次是应种
								Y_BD_JE_L2_Map.put(childcode, "842");
								// System.out.println(">>>乙脑减毒活疫苗2应种>>>");
								for (int k = 0; k < ff.size(); k++) {
									if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
										
										int a = ff.get(k).getJelBSh();
										ff.get(k).setJelBSh(++a);
										break;
									}
								}
							} else {
								// System.out.println(">>>乙脑减毒活疫苗2未到间隔>>>");
							}
						} else {
							// System.out.println("不做统计了");
						}
					}
				} else {
					
					if (vacc_yzrq.containsKey("841")  && situation.equals("1") && officeInfo.equals(office)) {
						// 乙脑减毒活疫苗1应种
						Y_BD_JE_L1_Map.put(childcode, "841");
						// System.out.println(">>>乙脑减毒活疫苗1应种>>>");
						for (int k = 0; k < ff.size(); k++) {
							if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
								
								int a = ff.get(k).getJelASh();
								ff.get(k).setJelASh(++a);
								break;
							}
						}
					} else {
						// System.out.println("不做统计了");
					}
						
					
				}
			
		}
	}

	//////////////////

	// 乙脑灭活1_2（未校验替代）(未做统计)
	public void do_JEI_1_2( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area, String createDate, String office, String situation, String officeInfo){
		
		Map<String, String> t_map_2 = (Map<String, String>) vacc_list.get("832");

		// 判断乙脑灭活疫苗第2针是否接种
		if (t_map_2 != null) {
			// 第2针乙脑灭活不为空
			if (Double.parseDouble((String) t_map_2.get("dif_mon")) < 1
					&& t_map_2.get("office").equals(office) && !(t_map_2.get("source").equals("3"))) {
				// 判断第2针接种时间是否在当月

				// 乙脑灭活2针次是应种针次
				Y_BD_JE_I2_Map.put(childcode, "832");
				S_BD_JE_I2_Map.put(childcode, "832");

				// System.out.println(">>>乙脑灭活疫苗2应种实种 >>>");
			} else {

				// System.out.println(">>>乙脑灭活疫苗2已经接种很久了 >>>");
			}

		} else {
			if (vacc_yzrq.containsKey("832")  && situation.equals("1") && officeInfo.equals(office)) {
				// 乙脑灭活2针次是应种针次
				Y_BD_JE_I2_Map.put(childcode, "832");
				
				// System.out.println(">>>乙脑灭活疫苗2应种 >>>");
			} else {
				// System.out.println("不做统计了");
			}
		}
		
		Map<String, String> t_map_1 = (Map<String, String>) vacc_list.get("831");

		// 判断乙脑灭活疫苗第1 针是否接种
		if (t_map_1 != null) {
			// 第一针乙脑灭活不为空
			if (Double.parseDouble((String) t_map_1.get("dif_mon")) < 1
					&& t_map_1.get("office").equals(office) && !(t_map_1.get("source").equals("3"))) {
				// 判断第1针接种是否在当月

				// 乙脑灭活1针次是应种针次
				Y_BD_JE_I1_Map.put(childcode, "831");
				S_BD_JE_I1_Map.put(childcode, "831");
				
				// System.out.println(">>>乙脑灭活疫苗1应种实种>>>");
			} else {
				// System.out.println(">>>乙脑灭活疫苗1已经接种很久了 >>>");
			}
		} else {
			if (vacc_yzrq.containsKey("831")  && situation.equals("1") && officeInfo.equals(office)) {
				// 第一针乙脑灭活为空
				// 乙脑灭活第1针次和第二针次都是应种（因为两针一起接种）
				Y_BD_JE_I1_Map.put(childcode, "831");
				
				// System.out.println(">>>乙脑灭活疫苗1应种 >>>");
			} else {
				// System.out.println("不做统计了");
			}
		}

	}

	// 乙脑灭活3（未校验替代）(未做统计)
	public void do_JEI_3( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area, String createDate, String office, String situation, String officeInfo){
		
		Map<String, String> t_map_3 = (Map<String, String>) vacc_list.get("833");
		
		// 判断乙脑灭活第3针是否有接种纪录
		if (t_map_3 != null) {
			// 乙脑灭活第3针已经有接种纪录
			if (Double.parseDouble((String) t_map_3.get("dif_mon")) < 1
					&& t_map_3.get("office").equals(office) && !(t_map_3.get("source").equals("3"))) {
				// 判断第3针接种时间是否在当月

				// 乙脑灭活3针次是应种针次
				Y_BD_JE_I3_Map.put(childcode, "833");
				S_BD_JE_I3_Map.put(childcode, "833");
				
				// System.out.println(">>>乙脑灭活疫苗3应种 实种>>>");
			} else {

				// System.out.println(">>>乙脑灭活疫苗3已经接种 很久了 >>>");
			}
		} else {
			
			Map<String, String> t_map_2 = (Map<String, String>) vacc_list.get("832");
			
			// 判断乙脑灭活疫苗第2针是否接种
			if (t_map_2 != null) {
				// 第2针乙脑灭活不为空
				if (Double.parseDouble((String) t_map_2.get("dif_mon")) < 1
						&& t_map_2.get("office").equals(office) && !(t_map_2.get("source").equals("3"))) {
					// 判断第2针接种时间是否在当月

					// 乙脑灭活2针次是应种针次
					Y_BD_JE_I2_Map.put(childcode, "832");
					S_BD_JE_I2_Map.put(childcode, "832");
					
					// System.out.println(">>>乙脑灭活疫苗2应种实种 >>>");
				} else {
					if (vacc_yzrq.containsKey("833")  && situation.equals("1") && officeInfo.equals(office)) {
						// 乙脑灭活3针次是应种针次
						Y_BD_JE_I3_Map.put(childcode, "833");

						// System.out.println(">>>乙脑灭活疫苗3应种 >>>");
					} else {
						// System.out.println("不做统计了");
					}
				}

			} else {
				
				Map<String, String> t_map_1 = (Map<String, String>) vacc_list.get("831");
				
				// 判断乙脑灭活疫苗第1 针是否接种
				if (t_map_1 != null) {
					// 第一针乙脑灭活不为空
					if (Double.parseDouble((String) t_map_1.get("dif_mon")) < 1
							&& t_map_1.get("office").equals(office) && !(t_map_1.get("source").equals("3"))) {
						// 判断第1针接种是否在当月

						// 乙脑灭活1针次是应种针次
						Y_BD_JE_I1_Map.put(childcode, "831");
						S_BD_JE_I1_Map.put(childcode, "831");
						
						// System.out.println(">>>乙脑灭活疫苗1应种实种>>>");
					} else {
						if (vacc_yzrq.containsKey("832")  && situation.equals("1") && officeInfo.equals(office)) {

							// 乙脑灭活2针次是应种针次
							Y_BD_JE_I2_Map.put(childcode, "832");
							
							// System.out.println(">>>乙脑灭活疫苗2应种 >>>");
						} else {
							// System.out.println("不做统计了");
						}
					}
				} else {
					if (vacc_yzrq.containsKey("831")  && situation.equals("1") && officeInfo.equals(office)) {
						// 第一针乙脑灭活为空
						// 乙脑灭活第1针次是应种
						Y_BD_JE_I1_Map.put(childcode, "831");
						
						// System.out.println(">>>乙脑灭活疫苗1应种 >>>");
					} else {
						// System.out.println("不做统计了");
					}
				}
			}
		}

	}

	// 乙脑灭活4（未校验替代）(未做统计)
	public void do_JEI_4( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area, String createDate, String office, String situation, String officeInfo){
		
		Map<String, String> t_map_4 = (Map<String, String>) vacc_list.get("834");

		if (t_map_4 != null) {
			// 乙脑灭活疫苗第4针有接种记录

			if (Double.parseDouble((String) t_map_4.get("dif_mon")) < 1
					&& t_map_4.get("office").equals(office) && !(t_map_4.get("source").equals("3"))) {
				// 判断接种时间是否在当月
				Y_BD_JE_I4_Map.put(childcode, "834");
				S_BD_JE_I4_Map.put(childcode, "834");
				
				// System.out.println(">>>乙脑灭活疫苗4应种实种 >>>");
			}

			/// 很早就接种了

		} else {
			
			Map<String, String> t_map_3 = (Map<String, String>) vacc_list.get("833");
			
			// 判断乙脑灭活第3针是否有接种纪录
			if (t_map_3 != null) {
				// 乙脑灭活第3针已经有接种纪录
				if (Double.parseDouble((String) t_map_3.get("dif_mon")) < 1
						&& t_map_3.get("office").equals(office) && !(t_map_3.get("source").equals("3"))) {
					// 判断第3针接种时间是否在当月

					// 乙脑灭活3针次是应种针次
					Y_BD_JE_I3_Map.put(childcode, "833");
					S_BD_JE_I3_Map.put(childcode, "833");
					
					// System.out.println(">>>乙脑灭活疫苗3应种实种 >>>");
				} else {
					if (vacc_yzrq.containsKey("834")  && situation.equals("1") && officeInfo.equals(office)) {
						// 乙脑灭活第4针次是应种
						Y_BD_JE_I4_Map.put(childcode, "834");
						
						// System.out.println(">>>乙脑灭活疫苗4应种>>>");
					} else {
						// System.out.println("不做统计了");
					}
				}
			} else {
				
				Map<String, String> t_map_2 = (Map<String, String>) vacc_list.get("832");
				
				// 判断乙脑灭活疫苗第2针是否接种
				if (t_map_2 != null) {
					// 第2针乙脑灭活不为空
					if (Double.parseDouble((String) t_map_2.get("dif_mon")) < 1
							&& t_map_2.get("office").equals(office) && !(t_map_2.get("source").equals("3"))) {
						// 判断第2针接种时间是否在当月

						// 乙脑灭活2针次是应种针次
						Y_BD_JE_I2_Map.put(childcode, "832");
						S_BD_JE_I2_Map.put(childcode, "832");
						
						// System.out.println(">>>乙脑灭活疫苗2应种实种 >>>");
					} else {
						if (vacc_yzrq.containsKey("833")  && situation.equals("1") && officeInfo.equals(office)) {
							// 乙脑灭活3针次是应种针次
							Y_BD_JE_I3_Map.put(childcode, "833");
							
							// System.out.println(">>>乙脑灭活疫苗3应种 >>>");
						} else {
							// System.out.println("不做统计了");
						}
					}

				} else {
					
					Map<String, String> t_map_1 = (Map<String, String>) vacc_list.get("831");
					
					// 判断乙脑灭活疫苗第1 针是否接种
					if (t_map_1 != null) {
						// 第一针乙脑灭活不为空
						if (Double.parseDouble((String) t_map_1.get("dif_mon")) < 1
								&& t_map_1.get("office").equals(office) && !(t_map_1.get("source").equals("3"))) {
							// 判断第1针接种是否在当月

							// 乙脑灭活1针次是应种针次
							Y_BD_JE_I1_Map.put(childcode, "831");
							S_BD_JE_I1_Map.put(childcode, "831");
							
							// System.out.println(">>>乙脑灭活疫苗1应种实种>>>");
						} else {
							if (vacc_yzrq.containsKey("832")  && situation.equals("1") && officeInfo.equals(office)) {
								// 乙脑灭活2针次是应种针次
								Y_BD_JE_I2_Map.put(childcode, "832");
								
								
								// System.out.println(">>>乙脑灭活疫苗2应种 >>>");
							} else {
								// System.out.println("不做统计了");
							}
						}
					} else {
						if (vacc_yzrq.containsKey("831")  && situation.equals("1") && officeInfo.equals(office)) {
							// 第一针乙脑灭活为空
							// 乙脑灭活第1针次是应种
							Y_BD_JE_I1_Map.put(childcode, "831");
							
							// System.out.println(">>>乙脑灭活疫苗1应种 >>>");
						} else {
							// System.out.println("不做统计了");
						}
					}
				}
			}
		}
	}

	/////////////////////////////////////

	// 麻腮风
	public void do_MMR_1( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area, String createDate, String office, String situation, String officeInfo){
		
		Map<String, String> t_map_1 = (Map<String, String>) vacc_list.get("121");
		
		//TODO:统计麻腮风疫苗接种时间在生成数据的月份内且当月月龄超过84岁的情况,加入应种实种

		if (t_map_1 == null) {
			if (vacc_yzrq.containsKey("121")  && situation.equals("1") && officeInfo.equals(office)) {
				// 麻腮风
				Y_BD_MMR1_Map.put(childcode, vacc_list.get("121"));

				// System.out.println("麻腮风应种");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						
						int a = ff.get(k).getMmrASh();
						ff.get(k).setMmrASh(++a);
						break;
					}
				}

			} else {
				// System.out.println("不做统计了");
			}
		} else {

			if (Double.parseDouble((String) t_map_1.get("dif_mon")) < 1
					&& t_map_1.get("office").equals(office) && !(t_map_1.get("source").equals("3"))) {
				// 判断接种时间是否在当月
				Y_BD_MMR1_Map.put(childcode, "121");
				S_BD_MMR1_Map.put(childcode, "121");

				// System.out.println(">>>麻腮风疫苗1应种实种 >>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getMmrARe();
						ff.get(k).setMmrARe(++a);
						a = ff.get(k).getMmrASh();
						ff.get(k).setMmrASh(++a);
						break;
					}
				}
			}
		}
	}
	
	
	/**
	 * 统计麻腮风接种月龄大于18个月份的情况,如果月龄大于18个月后接种了麻腮风第二针,则应种实种数都+1
	 * @author Jack
	 * @date 2018年2月2日 下午6:14:05
	 * @description 
	 * @param vacc_list
	 * @param childcode
	 * @param vacc_yzrq
	 * @param reside
	 * @param area
	 * @param createDate
	 * @param office
	 * @param situation
	 * @param officeInfo
	 *
	 */
	public void do_MMR_2( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area, String createDate, String office, String situation, String officeInfo){
		
		Map<String, String> t_map_1 = (Map<String, String>) vacc_list.get("122");
		
		if (t_map_1 != null) {
			if (Double.parseDouble((String) t_map_1.get("dif_mon")) < 1
					&& t_map_1.get("office").equals(office) && !(t_map_1.get("source").equals("3"))) {
				// 判断接种时间是否在当月
				Y_BD_MMR1_Map.put(childcode, "122");
				S_BD_MMR1_Map.put(childcode, "122");

				// System.out.println(">>>麻腮风疫苗1应种实种 >>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getMmrARe();
						ff.get(k).setMmrARe(++a);
						a = ff.get(k).getMmrASh();
						ff.get(k).setMmrASh(++a);
						break;
					}
				}
			}
		}
	}
	
	
	
	////////////////////////////////////

	// 甲肝减毒活疫苗
	public void do_HEPAL_1( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area, String createDate, String office, String situation, String officeInfo) {
		
		Map<String, String> t_map_1 = (Map<String, String>) vacc_list.get("821");

		if (t_map_1 == null) {
			if (vacc_yzrq.containsKey("821")  && situation.equals("1") && officeInfo.equals(office)) {
				// 甲肝
				Y_BD_HepA_L1_Map.put(childcode, vacc_list.get("821"));
				
				// System.out.println("甲肝减毒活疫苗应种");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getHepalSh();
						ff.get(k).setHepalSh(++a);
						break;
					}
				}
			} else {
				// System.out.println("不做统计了");
			}
		} else {

			if (Double.parseDouble((String) t_map_1.get("dif_mon")) < 1
					&& t_map_1.get("office").equals(office) && !(t_map_1.get("source").equals("3"))) {
				// 判断接种时间是否在当月
				Y_BD_HepA_L1_Map.put(childcode, "821");
				S_BD_HepA_L1_Map.put(childcode, "821");
				// System.out.println(">>>甲肝减毒活疫苗应种实种 >>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getHepalRe();
						ff.get(k).setHepalRe(++a);
						a = ff.get(k).getHepalSh();
						ff.get(k).setHepalSh(++a);
						break;
					}
				}
			}
		}
	}

	////////////////////////////////////////////

	// 甲肝灭活疫苗1
	public void do_HEPAI_1( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area, String createDate, String office, String situation, String officeInfo){
		
		Map<String, String> t_map_1 = (Map<String, String>) vacc_list.get("811");

		// 判断甲肝灭活疫苗第1针是否有接种纪录
		if (t_map_1 != null) {
			// 甲肝灭活疫苗第1针已经有接种纪录
			if (Double.parseDouble((String) t_map_1.get("dif_mon")) < 1
					&& t_map_1.get("office").equals(office) && !(t_map_1.get("source").equals("3"))) {
				// 判断第1针接种时间是否在当月

				// 甲肝灭活疫苗第1针次是应种针次
				Y_BD_HepA_I1_Map.put(childcode, "811");
				S_BD_HepA_I1_Map.put(childcode, "811");
				// System.out.println(">>>甲肝灭活疫苗1应种实种 >>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getHepaiARe();
						ff.get(k).setHepaiARe(++a);
						a = ff.get(k).getHepaiASh();
						ff.get(k).setHepaiASh(++a);
						break;
					}
				}
			} else {
				// System.out.println(">>>甲肝灭活疫苗1已经接种很久了 >>>>>>>");
			}
		} else {
		
			if (vacc_yzrq.containsKey("811") && situation.equals("1") && officeInfo.equals(office)) {
				// 甲肝灭活疫苗1应种
				Y_BD_HepA_I1_Map.put(childcode, "811");

				// System.out.println(">>>甲肝灭活疫苗1应种>>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getHepaiASh();
						ff.get(k).setHepaiASh(++a);
						break;
					}
				}
			} else {
				// System.out.println("不做统计了");
			}
			
		}

	}

	// 甲肝灭活疫苗2
	public void do_HEPAI_2( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area, String createDate, String office, String situation, String officeInfo){
		
		Map<String, String> t_map_2 = (Map<String, String>) vacc_list.get("812");

		if (t_map_2 != null) {
			// 甲肝灭活疫苗第2针有接种记录

			if (Double.parseDouble((String) t_map_2.get("dif_mon")) < 1
					&& t_map_2.get("office").equals(office) && !(t_map_2.get("source").equals("3"))) {
				// 判断接种时间是否在当月
				Y_BD_HepA_I2_Map.put(childcode, "812");
				S_BD_HepA_I2_Map.put(childcode, "812");

				// System.out.println(">>>甲肝灭活疫苗2应种实种 >>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getHepaiBRe();
						ff.get(k).setHepaiBRe(++a);
						a = ff.get(k).getHepaiBSh();
						ff.get(k).setHepaiBSh(++a);
						break;
					}
				}
			} else {
				// System.out.println(">>>甲肝灭活疫苗2已经接种很久了 >>>>>>>");
			}
		} else {
			
			Map<String, String> t_map_1 = (Map<String, String>) vacc_list.get("811");
			
			// 判断甲肝灭活疫苗第1针是否有接种纪录
			if (t_map_1 != null) {
				// 甲肝灭活疫苗第1针已经有接种纪录
				if (Double.parseDouble((String) t_map_1.get("dif_mon")) < 1
						&& t_map_1.get("office").equals(office) && !(t_map_1.get("source").equals("3"))) {
					// 判断第1针接种时间是否在当月

					// 甲肝灭活疫苗第1针次是应种针次
					Y_BD_HepA_I1_Map.put(childcode, "811");
					S_BD_HepA_I1_Map.put(childcode, "811");
					// System.out.println(">>>甲肝灭活疫苗1应种 实种>>>");
					for (int k = 0; k < ff.size(); k++) {
						if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
							
							int a = ff.get(k).getHepaiARe();
							ff.get(k).setHepaiARe(++a);
							a = ff.get(k).getHepaiASh();
							ff.get(k).setHepaiASh(++a);
							break;
						}
					}
				} else {
					if (vacc_yzrq.containsKey("812") && situation.equals("1") && officeInfo.equals(office)) {
						if (Double.parseDouble((String) t_map_1.get("dif_mon")) > 6) {
							// 甲肝灭活疫苗第2针次是应种
							Y_BD_HepA_I2_Map.put(childcode, "812");

							// System.out.println(">>>甲肝灭活疫苗2应种>>>");
							for (int k = 0; k < ff.size(); k++) {
								if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
									
									int a = ff.get(k).getHepaiBSh();
									ff.get(k).setHepaiBSh(++a);
									break;
								}
							}
						} else {
							// System.out.println(">>>甲肝灭活疫苗2未到间隔>>>");
						}
					} else {
						// System.out.println("不做统计了");
					}
				}
			} else {
				
				if (vacc_yzrq.containsKey("811") && situation.equals("1") && officeInfo.equals(office)) {
					// 甲肝灭活疫苗1应种
					Y_BD_HepA_I1_Map.put(childcode, "811");

					// System.out.println(">>>甲肝灭活疫苗1应种>>>");
					for (int k = 0; k < ff.size(); k++) {
						if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
							
							int a = ff.get(k).getHepaiASh();
							ff.get(k).setHepaiASh(++a);
							break;
						}
					}
				} else {
					// System.out.println("不做统计了");
				}
				
			}
		}
	}

	////////////////////////////////////

	// A+C群流脑多糖1
	public void do_MENAC_1( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area, String createDate, String office, String situation, String officeInfo){
		
		Map<String, String> t_map_1 = (Map<String, String>) vacc_list.get("171");

		// 判断A+C群流脑多糖疫苗第1针是否有接种纪录
		if (t_map_1 != null) {
			// A+C群流脑多糖疫苗第1针已经有接种纪录
			if (Double.parseDouble((String) t_map_1.get("dif_mon")) < 1
					&& t_map_1.get("office").equals(office) && !(t_map_1.get("source").equals("3"))) {
				// 判断第1针接种时间是否在当月

				// A+C群流脑多糖疫苗第1针次是应种针次
				Y_BD_MenAC1_Map.put(childcode, "171");
				S_BD_MenAC1_Map.put(childcode, "171");

				// System.out.println(">>>A+C群流脑多糖疫苗1应种实种 >>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getMenacARe();
						ff.get(k).setMenacARe(++a);
						a = ff.get(k).getMenacASh();
						ff.get(k).setMenacASh(++a);
						break;
					}
				}
			} else {
				// System.out.println(">>>A+C群流脑多糖疫苗1已经接种很久了>>>");
			}
		} else {
			
			if (vacc_yzrq.containsKey("171") && situation.equals("1") && officeInfo.equals(office)) {
				// A+C群流脑多糖疫苗1应种
				Y_BD_MenAC1_Map.put(childcode, "171");

				// System.out.println(">>>A+C群流脑多糖疫苗1应种>>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getMenacASh();
						ff.get(k).setMenacASh(++a);
						break;
					}
				}
			} else {
				// System.out.println("不做统计了");
			}
			
		}

	}

	// A+C群流脑多糖2
	public void do_MENAC_2( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area, String createDate, String office, String situation, String officeInfo) {
		
		Map<String, String> t_map_2 = (Map<String, String>) vacc_list.get("172");

		if (t_map_2 != null) {
			// A+C群流脑多糖疫苗第2针有接种记录

			if (Double.parseDouble((String) t_map_2.get("dif_mon")) < 1
					&& t_map_2.get("office").equals(office) && !(t_map_2.get("source").equals("3"))) {
				// 判断接种时间是否在当月
				Y_BD_MenAC2_Map.put(childcode, "172");
				S_BD_MenAC2_Map.put(childcode, "172");

				// System.out.println(">>>A+C群流脑多糖疫苗2应种实种 >>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getMenacBRe();
						ff.get(k).setMenacBRe(++a);
						a = ff.get(k).getMenacBSh();
						ff.get(k).setMenacBSh(++a);
						break;
					}
				}
			} else {
				// System.out.println(">>>A+C群流脑多糖疫苗2已经接种很久了>>>");
			}
		} else {
			
			Map<String, String> t_map_1 = (Map<String, String>) vacc_list.get("171");
			
			// 判断A+C群流脑多糖疫苗第1针是否有接种纪录
			if (t_map_1 != null) {
				// A+C群流脑多糖疫苗第1针已经有接种纪录
				if (Double.parseDouble((String) t_map_1.get("dif_mon")) < 1
						&& t_map_1.get("office").equals(office) && !(t_map_1.get("source").equals("3"))) {
					// 判断第1针接种时间是否在当月

					// A+C群流脑多糖疫苗第1针次是应种针次
					Y_BD_MenAC1_Map.put(childcode, "171");
					S_BD_MenAC1_Map.put(childcode, "171");

					// System.out.println(">>>A+C群流脑多糖疫苗1应种 实种>>>");
					for (int k = 0; k < ff.size(); k++) {
						if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
							
							int a = ff.get(k).getMenacARe();
							ff.get(k).setMenacARe(++a);
							a = ff.get(k).getMenacASh();
							ff.get(k).setMenacASh(++a);
							break;
						}
					}
				} else {
					if (vacc_yzrq.containsKey("172") && situation.equals("1") && officeInfo.equals(office)) {
						if (Double.parseDouble((String) t_map_1.get("dif_mon")) > 36) {
							// A+C群流脑多糖疫苗第2针次是应种
							Y_BD_MenAC2_Map.put(childcode, "172");

							// System.out.println(">>>A+C群流脑多糖疫苗2应种>>>");
							for (int k = 0; k < ff.size(); k++) {
								if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
									
									int a = ff.get(k).getMenacBSh();
									ff.get(k).setMenacBSh(++a);
									break;
								}
							}
						} else {
							// System.out.println(">>>A+C群流脑多糖疫苗2未到间隔>>>");
						}
					} else {
						// System.out.println("不做统计了");
					}
				}
			} else {
				
				if (vacc_yzrq.containsKey("171") && situation.equals("1") && officeInfo.equals(office)) {
					// A+C群流脑多糖疫苗1应种
					Y_BD_MenAC1_Map.put(childcode, "171");

					// System.out.println(">>>A+C群流脑多糖疫苗1应种>>>");
					for (int k = 0; k < ff.size(); k++) {
						if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
							
							int a = ff.get(k).getMenacASh();
							ff.get(k).setMenacASh(++a);
							break;
						}
					}
				} else {
					// System.out.println("不做统计了");
				}
				
			}
		}
	}

	//////////////////////////////////////
	
	// 白破1
	public void do_DT_1( Map vacc_list ,String childcode,Map vacc_yzrq,String reside,String area, String createDate, String office, String situation, String officeInfo){
		
		Map<String, String> t_map_1 = (Map<String, String>) vacc_list.get("061");
		
		if (t_map_1 == null) {
			if (vacc_yzrq.containsKey("061") && situation.equals("1") && officeInfo.equals(office)) {
				// 白破
				Y_BD_DT1_Map.put(childcode, vacc_list.get("061"));
				
				// System.out.println("白破疫苗1应种");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getDtSh();
						ff.get(k).setDtSh(++a);
						break;
					}
				}
			} else {
				// System.out.println("不做统计了");
			}
		} else {
			if (Double.parseDouble((String) t_map_1.get("dif_mon")) < 1
					&& t_map_1.get("office").equals(office) && !(t_map_1.get("source").equals("3"))) {
				// 判断接种时间是否在当月
				Y_BD_DT1_Map.put(childcode, "061");
				S_BD_DT1_Map.put(childcode, "061");

				// System.out.println(">>>白破疫苗1应种实种 >>>");
				for (int k = 0; k < ff.size(); k++) {
					if (ff.get(k).getReside().equals(reside) && ff.get(k).getUnitCode().equals(area)) {
						
						int a = ff.get(k).getDtRe();
						ff.get(k).setDtRe(++a);
						a = ff.get(k).getDtSh();
						ff.get(k).setDtSh(++a);
						break;
					}
				}
			}
		}

	}
	////////////////////////////////

	@Override
	public ExpRoutinevacc6_1 get(String id) {
		return super.get(id);
	}

//	@Transactional(readOnly = false)
	@Override
	public void save(ExpRoutinevacc6_1 expRoutinevacc6_1) {
		super.save(expRoutinevacc6_1);
	}

	@Override
	@Transactional(readOnly = false)
	public void delete(ExpRoutinevacc6_1 expRoutinevacc6_1) {
		super.delete(expRoutinevacc6_1);
	}

	public void inster(ExpRoutinevacc6_1 expRoutinevacc6_1) {
		super.insert(expRoutinevacc6_1);
	}

	// ------------------------------------------------------------------------------------------
	// -------------------------------常规免疫6-1开始-------------------------------------------//
	// ------------------------------------------------------------------------------------------

	// --------------------------------------常规免疫6-1map数据处理开始------------------------------------------//
	/**
	 * 常规免疫接种 情况汇总表6-1 查询数据 =>按居住类型
	 * 
	 * @author Jack
	 * @date 2017年9月20日 上午11:15:48
	 * @param map
	 * @return
	 *
	 */
	public List<HashMap<String, String>> selectVaccData61_unit(HashMap<String, String> map) {
		return dao.selectVaccData61_unit(map);
	}

	/**
	 * 常规免疫接种 情况汇总表6-1 查询数据 =>按社区 s分居住类型
	 * 
	 * @author Jack
	 * @date 2017年9月20日 下午2:22:51
	 * @param map
	 * @return
	 *
	 */
	public List<HashMap<String, String>> selectVaccData61_unitAndReside(HashMap<String, String> map) {
		return dao.selectVaccData61_unitAndReside(map);
	}

	/**
	 * 常规免疫接种 情况汇总表6-1 查询数据 =>按社区 不分居住类型
	 * 
	 * @author Jack
	 * @date 2017年9月20日 下午2:24:45
	 * @param map
	 * @return
	 *
	 */
	public List<HashMap<String, String>> selectVaccData61_unitNoReside(HashMap<String, String> map) {
		return dao.selectVaccData61_unitNoReside(map);
	}
	
	/**
	 * 常规免疫接种情况汇总表6-1 特殊类型疫苗统计
	 * @author Jack
	 * @date 2017年10月25日 下午7:07:24
	 * @description 
	 * @param map
	 * @return
	 *
	 */
	public List<HashMap<String, String>> selectVaccSpecData61_unitNoReside(HashMap<String,String> map){
		return dao.selectVaccSpecData61_unitNoReside(map);
	}
	
	/**
	 * 常规免疫接种 情况汇总表6-1 查询数据 总合计
	 * 
	 * @author Jack
	 * @date 2017年9月20日 下午2:26:15
	 * @param map
	 * @return
	 *
	 */
	public List<HashMap<String, String>> selectVaccData61_all(HashMap<String, String> map) {
		return dao.selectVaccData61_all(map);
	}
	
	/**
	 * 查询下一层级非根子节点数据
	 * @author Jack
	 * @date 2017年11月7日 上午9:09:26
	 * @description 
	 * @param map
	 * @return
	 *
	 */
	public List<HashMap<String, Object>> selectNextLevelData(String officeCode, String startTime, String endTime){
		return dao.selectNextLevelData(officeCode, startTime, endTime);
	}

	// --------------------------------------常规免疫6-1map数据处理结束------------------------------------------//

	/**
	 * 查询Reside
	 * 
	 * @author Jack
	 * @date 2017年10月13日 上午9:56:37
	 * @param list_reside
	 * @return
	 *
	 */
	public List<ExpRoutinevacc6_1> selectResideList() {
		return dao.selectResideList();
	}

	/**
	 * 查询Community
	 * 
	 * @author Jack
	 * @date 2017年10月13日 上午9:57:48
	 * @param list_community
	 * @return
	 *
	 */
	public List<ExpRoutinevacc6_1> selectCommunityList(String officeStr) {
		return dao.selectCommunityList(officeStr);
	}

	/**
	 * 查询7岁内全部记录
	 * 
	 * @author Jack
	 * @date 2017年10月13日 上午10:31:51
	 * @param sql_total
	 * @return
	 *
	 */
	public List<ExpRoutinevacc6_1> selectTotalList() {
		return dao.selectTotalList();
	}

	/**
	 * 查询7岁内全部记录，并拼接community、reside
	 * @author Jack
	 * @date 2018年3月1日 上午2:18:18
	 * @description 
	 * @param monthNum
	 * @param officeStr
	 * @return
	 *
	 */
	public List<Map<String, String>> selectSqlQuery(Integer monthNum, String officeStr) {
		return dao.selectSqlQuery(monthNum, officeStr);
		
	}
	
	
	
	/**
	 * 6-1主要查询逻辑1 
	 * @author Jack
	 * @date 2018年3月1日 上午2:19:19
	 * @description 
	 * @param id
	 * @param monthNum
	 * @return
	 *
	 */
	public List<Map<String, String>> selectSqlList(String id, Integer monthNum){
		return dao.selectSqlList(id, monthNum);
	}
	
	
	
	/**
	 * 6-1主要查询逻辑2
	 * @author Jack
	 * @date 2018年3月1日 上午2:20:21
	 * @description 
	 * @param id
	 * @param monthNum
	 * @return
	 *
	 */
	private List<Map<String, String>> selectSqlYzrq(String id, Integer monthNum){
		return dao.selectSqlYzrq(id, monthNum);
	}
	
	
	
	/**
	 * 获取选中非根子节点时的数据
	 * @author Jack
	 * @date 2017年11月10日 下午4:46:47
	 * @description 
	 * 树结构拼接:
	 * 1、拼接整个树结构                                                                                 	
	 * 2、省去树结构中间节点,只保存树结构根子节点                                                                    
	 * 3、遍历获取所有的Office ID(Map主键),存入Map<Office,<br>
	 *  List<Office>>集合中List<Office>为节点ID为String的节点的所有子节点(此处使用此方法)
	 *
	 */
	public HashMap<String, Object> getNotEndChildNodeData(String officeId, String startTime, String endTime){
		HashMap<String, Object> returnMap = getNextLevelList(officeId);
		@SuppressWarnings("unchecked")
		List<Office> nextLevelList = (List<Office>) returnMap.get("nextLevelList");
		@SuppressWarnings("unchecked")
		Map<String, List<Office>> nowNextNodeMap = (Map<String, List<Office>>) returnMap.get("nowNextNodeMap");
		HashMap<Office,List<Office>> nextNodeAllNodesMap = new HashMap<Office, List<Office>>(); // key:下级节点,value:下级节点下的所有根子节点
		
		//存储当前节点的每个下级节点对应的所有根子节点
		for(Office off : nextLevelList){
			List<Office> oneNodeAllChildsList = new ArrayList<Office>();
			List<Office> tmpList = getNextLevelSumData(nowNextNodeMap, off, oneNodeAllChildsList);
			nextNodeAllNodesMap.put(off, tmpList);
		}
		
		//统计当前节点下每个非根子节点数据
		return getNextLevelResultData(nextNodeAllNodesMap, startTime, endTime); 
	}
	
	
	
	/**
	 * 递归计算当前登陆账号下Office的某个下级子节点下的所有根子节点
	 * @author Jack
	 * @date 2017年11月10日 下午4:35:09
	 * @description 
	 * @param nowNextNodeMap 完全目录树结构集合
	 * @param office 初次传入为当前登陆账号的Office
	 * @param oneNodeAllChildsList 当前节点的某个下级节点的所有根子节点集合
	 * @return 当前登陆账号下Office的某个下级子节点下的所有根子节点集合
	 *
	 */
	public List<Office> getNextLevelSumData(Map<String, List<Office>> nowNextNodeMap, Office office, List<Office> oneNodeAllChildsList){
		List<Office> tmpList = nowNextNodeMap.get(office.getId());
		if(tmpList == null){
			//tmpList集合为空,当前节点已经是根子节点,将当前节点存入oneNodeAllChildsList集合
			oneNodeAllChildsList.add(office);
		}else{
			//tmpList不是根子节点,递归遍历tmpList元素
			for(Office off : tmpList){
				String officeName = off.getName();
				Integer len = officeName.length();
				if((len>8 && StringUtils.substring(officeName,len-8, len).equals("疾病预防控制中心")) 
						|| (len>3 && StringUtils.substring(officeName,len-3, len).equals("ADR"))){
					continue;
				}
				getNextLevelSumData(nowNextNodeMap, off, oneNodeAllChildsList);
			}
		}
		return oneNodeAllChildsList;
	}
	
	
	
	
	/**
	 * 获取下级列表元素,若下级列表为空isEndCHildNode存入true
	 * @author Jack
	 * @date 2017年11月13日 下午7:26:36
	 * @description 
	 * @param officeId
	 * @return
	 *
	 */
	public HashMap<String,Object> getNextLevelList(String officeId){
		User user = null;
		Office nowOffice = null;
		if(officeId == null){
			user = UserUtils.getUser(); //获取当前登陆用户的用户ID(SYS_USER-->ID)
			nowOffice = user.getOffice(); //登陆User所属Office
		}else{
			nowOffice = Office.getOfficeByOfficeCode(officeId);
		}
		
		List<Office> allList = UserUtils.getOfficeAllList(); //获取所有列表
		//----------------------------计算树层次开始-------------------------//
		Set<Office> idSet = new HashSet<Office>();
		for(Office outOff : allList){
			for(Office innerOff : allList){
				if(outOff.getId().equals(innerOff.getParentId())){
					//outOff有子节点
					idSet.add(outOff);
				}
			}
		}
		Map<String, List<Office>> nowNextNodeMap = new HashMap<String, List<Office>>();
		for(Office outOff : idSet){
			List<Office> childList = new ArrayList<Office>();
			for(Office innerOff : allList){
				if(outOff.getId().equals(innerOff.getParentId())){
					childList.add(innerOff);
				}
			}
			nowNextNodeMap.put(outOff.getId(), childList);
		}
		//----------------------------计算树层次结束-------------------------//
		
		//---------计算下级节点列表(已去除所有疾控中心和ADR节点)开始----------------//
		List<Office> tmpNextLevelList = null;
		if(officeId == null && !nowOffice.getId().equals("1")){
			tmpNextLevelList = nowNextNodeMap.get(nowOffice.getParentId());
		}else{
			tmpNextLevelList = nowNextNodeMap.get(nowOffice.getId());
		}
		List<Office> nextLevelList = new ArrayList<Office>();
		HashMap<String,Object> returnMap = new HashMap<String, Object>();
		if(tmpNextLevelList != null){
			if(tmpNextLevelList != null){
				for(Office off : tmpNextLevelList){
					String officeName = off.getName();
					Integer len = officeName.length();
					if((len>8 && StringUtils.substring(officeName,len-8, len).equals("疾病预防控制中心")) 
							|| (len>3 && StringUtils.substring(officeName,len-3, len).equals("ADR"))){
						continue;
					}
					nextLevelList.add(off);
				}
			}
		}else{
			//当前节点已经为根子节点,需要查询所有详细信息
			returnMap.put("isEndCHildNode",true);
			return returnMap;
		}
		//---------计算下级节点列表(已去除所有疾控中心和ADR节点)结束----------------//
		returnMap.put("isEndCHildNode",false);
		returnMap.put("nextLevelList", nextLevelList);
		returnMap.put("nowNextNodeMap", nowNextNodeMap);
		return returnMap;
	}
	
	
	
	/**
	 * 获取所有的下层节点统计数据
	 * @author Jack
	 * @date 2017年11月10日 下午6:21:46
	 * @description 
	 *
	 */
	public HashMap<String, Object> getNextLevelResultData(HashMap<Office,List<Office>> nextNodeAllNodesMap, String startTime, String endTime){
		Integer index = 0; //地区序号
		StringBuffer returnStr = new StringBuffer("[");
		HashMap<String, Object> resultMap = new HashMap<String, Object>();
		List<HashMap<String, Object>> resultList = new ArrayList<HashMap<String, Object>>();
		List<Integer> resultREList = new ArrayList<Integer>();
		List<Integer> resultSHList = new ArrayList<Integer>();
		List<String> resultSRList = new ArrayList<String>();
		for(Office key : nextNodeAllNodesMap.keySet()){
			index++; //序号
			String officeArea = key.getName(); //区域名称
			String officeId = key.getId(); //区域编码
			HashMap<String, Object> tmpMap = new HashMap<String, Object>();
			List<HashMap<String, Object>> jsonList = null;
			DecimalFormat df = new DecimalFormat("#.00");
			
			for(Office off : nextNodeAllNodesMap.get(key)){
				//key:下级节点; off:该节点下的具体根子节点
				jsonList = new ArrayList<HashMap<String, Object>>();
				List<HashMap<String, Object>> childs = selectNextLevelData(off.getCode(), startTime, endTime);
				for(HashMap<String, Object> map : childs){
					
					Y_CHILDS_BCG += Integer.parseInt(map.get("BCG_SH").toString());
					Y_CHILDS_JSS += Integer.valueOf(map.get("HEPB_AA_SH").toString());
					Y_CHILDS_HepB1 += Integer.valueOf(map.get("HEPB_A_SH").toString());
					Y_CHILDS_HepB2 += Integer.valueOf(map.get("HEPB_B_SH").toString());
					Y_CHILDS_HepB3 += Integer.valueOf(map.get("HEPB_C_SH").toString());		
					Y_CHILDS_PV1 += Integer.valueOf(map.get("PV_A_SH").toString());
					Y_CHILDS_PV2 += Integer.valueOf(map.get("PV_B_SH").toString());
					Y_CHILDS_PV3 += Integer.valueOf(map.get("PV_C_SH").toString());
					Y_CHILDS_PV4 += Integer.valueOf(map.get("PV_D_SH").toString());				
					Y_CHILDS_DTP1 += Integer.valueOf(map.get("DTP_A_SH").toString());
					Y_CHILDS_DTP2 += Integer.valueOf(map.get("DTP_B_SH").toString());
					Y_CHILDS_DTP3 += Integer.valueOf(map.get("DTP_C_SH").toString());
					Y_CHILDS_DTP4 += Integer.valueOf(map.get("DTP_D_SH").toString());				
					Y_CHILDS_DT1 += Integer.valueOf(map.get("DT_SH").toString());				
					Y_CHILDS_MR1 += Integer.valueOf(map.get("MR_A_SH").toString());
					Y_CHILDS_MR2 += Integer.valueOf(map.get("MR_B_SH").toString());				
					Y_CHILDS_MMR1 += Integer.valueOf(map.get("MMR_A_SH").toString());
					Y_CHILDS_MMR2 += Integer.valueOf(map.get("MMR_B_SH").toString());				
					Y_CHILDS_MM1 += Integer.valueOf(map.get("MM_A_SH").toString());
					Y_CHILDS_MM2 += Integer.valueOf(map.get("MM_B_SH").toString());				
					Y_CHILDS_MV1 += Integer.valueOf(map.get("MV_A_SH").toString());
					Y_CHILDS_MV2 += Integer.valueOf(map.get("MV_B_SH").toString());				
					Y_CHILDS_MENA1 += Integer.valueOf(map.get("MENA_A_SH").toString());
					Y_CHILDS_MENA2 += Integer.valueOf(map.get("MENA_B_SH").toString());				
					Y_CHILDS_MENAC1 += Integer.valueOf(map.get("MENAC_A_SH").toString());
					Y_CHILDS_MENAC2 += Integer.valueOf(map.get("MENAC_B_SH").toString());				
					Y_CHILDS_JE_L1 += Integer.valueOf(map.get("JEL_A_SH").toString());
					Y_CHILDS_JE_L2 += Integer.valueOf(map.get("JEL_B_SH").toString());				
					Y_CHILDS_JE_I1 += Integer.valueOf(map.get("JEI_A_SH").toString());
					Y_CHILDS_JE_I2 += Integer.valueOf(map.get("JEI_B_SH").toString());
					Y_CHILDS_JE_I3 += Integer.valueOf(map.get("JEI_C_SH").toString());
					Y_CHILDS_JE_I4 += Integer.valueOf(map.get("JEI_D_SH").toString());				
					Y_CHILDS_HepA_L1 += Integer.valueOf(map.get("HEPAL_SH").toString());				
					Y_CHILDS_HepA_I1 += Integer.valueOf(map.get("HEPAI_A_SH").toString());
					Y_CHILDS_HepA_I2 += Integer.valueOf(map.get("HEPAI_B_SH").toString());
					
					// 子节点实种本地
					S_CHILDS_BCG += Integer.valueOf(map.get("BCG_RE").toString());				
					S_CHILDS_JSS += Integer.valueOf(map.get("HEPB_AA_RE").toString());				                       
					S_CHILDS_HepB1 += Integer.valueOf(map.get("HEPB_A_RE").toString());				              
					S_CHILDS_HepB2 += Integer.valueOf(map.get("HEPB_B_RE").toString());				              
					S_CHILDS_HepB3 += Integer.valueOf(map.get("HEPB_C_RE").toString());				
					S_CHILDS_PV1 += Integer.valueOf(map.get("PV_A_RE").toString());
					S_CHILDS_PV2 += Integer.valueOf(map.get("PV_B_RE").toString());
					S_CHILDS_PV3 += Integer.valueOf(map.get("PV_C_RE").toString());
					S_CHILDS_PV4 += Integer.valueOf(map.get("PV_D_RE").toString());				
					S_CHILDS_DTP1 += Integer.valueOf(map.get("DTP_A_RE").toString());
					S_CHILDS_DTP2 += Integer.valueOf(map.get("DTP_B_RE").toString());
					S_CHILDS_DTP3 += Integer.valueOf(map.get("DTP_C_RE").toString());
					S_CHILDS_DTP4 += Integer.valueOf(map.get("DTP_D_RE").toString());				
					S_CHILDS_DT1 += Integer.valueOf(map.get("DT_RE").toString());				
					S_CHILDS_MR1 += Integer.valueOf(map.get("MR_A_RE").toString());				
					S_CHILDS_MR2 += Integer.valueOf(map.get("MR_B_RE").toString());				
					S_CHILDS_MMR1 += Integer.valueOf(map.get("MMR_A_RE").toString());
					S_CHILDS_MMR2 += Integer.valueOf(map.get("MMR_B_RE").toString());
					S_CHILDS_MM1 += Integer.valueOf(map.get("MM_A_RE").toString());
					S_CHILDS_MM2 += Integer.valueOf(map.get("MM_B_RE").toString());
					S_CHILDS_MV1 += Integer.valueOf(map.get("MV_A_RE").toString());
					S_CHILDS_MV2 += Integer.valueOf(map.get("MV_B_RE").toString());				
					S_CHILDS_MENA1 += Integer.valueOf(map.get("MENA_A_RE").toString());
					S_CHILDS_MENA2 += Integer.valueOf(map.get("MENA_B_RE").toString());
					S_CHILDS_MENAC1 += Integer.valueOf(map.get("MENAC_A_RE").toString());
					S_CHILDS_MENAC2 += Integer.valueOf(map.get("MENAC_B_RE").toString());				
					S_CHILDS_JE_L1 += Integer.valueOf(map.get("JEL_A_RE").toString());
					S_CHILDS_JE_L2 += Integer.valueOf(map.get("JEL_B_RE").toString());				
					S_CHILDS_JE_I1 += Integer.valueOf(map.get("JEI_A_RE").toString());
					S_CHILDS_JE_I2 += Integer.valueOf(map.get("JEI_B_RE").toString());
					S_CHILDS_JE_I3 += Integer.valueOf(map.get("JEI_C_RE").toString());
					S_CHILDS_JE_I4 += Integer.valueOf(map.get("JEI_D_RE").toString());				
					S_CHILDS_HepA_L1 += Integer.valueOf(map.get("HEPAL_RE").toString());				
					S_CHILDS_HepA_I1 += Integer.valueOf(map.get("HEPAI_A_RE").toString());
					S_CHILDS_HepA_I2 += Integer.valueOf(map.get("HEPAI_B_RE").toString());
				}
			}
			//接种率计算
			if(Y_CHILDS_BCG != 0){
				RE_CHILDS_BCG = df.format(((float)S_CHILDS_BCG / Y_CHILDS_BCG)*100);
			}
			if(Y_CHILDS_JSS != 0){
				 RE_CHILDS_JSS = df.format(((float) S_CHILDS_JSS/ Y_CHILDS_JSS)*100);
			}
			if(Y_CHILDS_HepB1 != 0){
				RE_CHILDS_HepB1 = df.format(((float) S_CHILDS_HepB1 / Y_CHILDS_HepB1)*100);
			}
			if(Y_CHILDS_HepB2 != 0){
				RE_CHILDS_HepB2 = df.format(((float) S_CHILDS_HepB2 / Y_CHILDS_HepB2)*100);
			}
			if(Y_CHILDS_HepB3 != 0){
				RE_CHILDS_HepB3 = df.format(((float) S_CHILDS_HepB3 / Y_CHILDS_HepB3)*100);
			}
			if(Y_CHILDS_PV1 != 0){
				RE_CHILDS_PV1 = df.format(((float) S_CHILDS_PV1 / Y_CHILDS_PV1)*100);
			}
			if(Y_CHILDS_PV2 != 0){
				RE_CHILDS_PV2 = df.format(((float) S_CHILDS_PV2 / Y_CHILDS_PV2)*100);
			}
			if(Y_CHILDS_PV3 != 0){
				RE_CHILDS_PV3 = df.format(((float) S_CHILDS_PV3 / Y_CHILDS_PV3)*100);
			}
			if(Y_CHILDS_PV4 != 0){
				RE_CHILDS_PV4 = df.format(((float) S_CHILDS_PV4 / Y_CHILDS_PV4)*100);
			}
			if(Y_CHILDS_DTP1 != 0){
				RE_CHILDS_DTP1 = df.format(((float) S_CHILDS_DTP1 / Y_CHILDS_DTP1)*100);
			}
			if(Y_CHILDS_DTP2 != 0){
				RE_CHILDS_DTP2 = df.format(((float) S_CHILDS_DTP2 / Y_CHILDS_DTP2)*100);
			}
			if(Y_CHILDS_DTP3 != 0){
				RE_CHILDS_DTP3 = df.format(((float) S_CHILDS_DTP3 / Y_CHILDS_DTP3)*100);
			}
			if(Y_CHILDS_DTP4 != 0){
				RE_CHILDS_DTP4 = df.format(((float) S_CHILDS_DTP4 / Y_CHILDS_DTP4)*100);
			}
			if(Y_CHILDS_DT1 != 0){
				RE_CHILDS_DT1 = df.format(((float) S_CHILDS_DT1 / Y_CHILDS_DT1)*100);
			}
			if(Y_CHILDS_MR1 != 0){
				RE_CHILDS_MR1 = df.format(((float) S_CHILDS_MR1 / Y_CHILDS_MR1)*100);
			}
			if(Y_CHILDS_MR2 != 0){
				RE_CHILDS_MR2 = df.format(((float) S_CHILDS_MR2 / Y_CHILDS_MR2)*100);
			}
			if(Y_CHILDS_MMR1 != 0){
				RE_CHILDS_MMR1 = df.format(((float) S_CHILDS_MMR1 / Y_CHILDS_MMR1)*100);
			}
			if(Y_CHILDS_MMR2 != 0){
				RE_CHILDS_MMR2 = df.format(((float) S_CHILDS_MMR2 / Y_CHILDS_MMR2)*100);
			}
			if(Y_CHILDS_MM1 != 0){
				RE_CHILDS_MM1 = df.format(((float) S_CHILDS_MM1 / Y_CHILDS_MM1)*100);
			}
			if(Y_CHILDS_MM2 != 0){
				RE_CHILDS_MM2 = df.format(((float) S_CHILDS_MM2 / Y_CHILDS_MM2)*100);
			}
			if(Y_CHILDS_MV1 != 0){
				RE_CHILDS_MV1 = df.format(((float) S_CHILDS_MV1 / Y_CHILDS_MV1)*100);
			}
			if(Y_CHILDS_MV2 != 0){
				RE_CHILDS_MV2 = df.format(((float) S_CHILDS_MV2 / Y_CHILDS_MV2)*100);
			}
			if(Y_CHILDS_MENA1 != 0){
				RE_CHILDS_MENA1 = df.format(((float) S_CHILDS_MENA1 / Y_CHILDS_MENA1)*100);
			}
			if(Y_CHILDS_MENA2 != 0){
				RE_CHILDS_MENA2 = df.format(((float) S_CHILDS_MENA2 / Y_CHILDS_MENA2)*100);
			}
			if(Y_CHILDS_MENAC1 != 0){
				RE_CHILDS_MENAC1 = df.format(((float) S_CHILDS_MENAC1 / Y_CHILDS_MENAC1)*100);
			}
			if(Y_CHILDS_MENAC2 != 0){
				RE_CHILDS_MENAC2 = df.format(((float) S_CHILDS_MENAC2 / Y_CHILDS_MENAC2)*100);
			}
			if(Y_CHILDS_JE_L1 != 0){
				RE_CHILDS_JE_L1 = df.format(((float) S_CHILDS_JE_L1 / Y_CHILDS_JE_L1)*100);
			}
			if(Y_CHILDS_JE_L2 != 0){
				RE_CHILDS_JE_L2 = df.format(((float) S_CHILDS_JE_L2 / Y_CHILDS_JE_L2)*100);
			}
			if(Y_CHILDS_JE_I1 != 0){
				RE_CHILDS_JE_I1 = df.format(((float) S_CHILDS_JE_I1 / Y_CHILDS_JE_I1)*100);
			}
			if(Y_CHILDS_JE_I2 != 0){
				RE_CHILDS_JE_I2 = df.format(((float) S_CHILDS_JE_I2 / Y_CHILDS_JE_I2)*100);
			}
			if(Y_CHILDS_JE_I3 != 0){
				RE_CHILDS_JE_I3 = df.format(((float) S_CHILDS_JE_I3 / Y_CHILDS_JE_I3)*100);
			}
			if(Y_CHILDS_JE_I4 != 0){
				RE_CHILDS_JE_I4 = df.format(((float) S_CHILDS_JE_I4 / Y_CHILDS_JE_I4)*100);
			}
			if(Y_CHILDS_HepA_L1 != 0){
				RE_CHILDS_HepA_L1 = df.format(((float) S_CHILDS_HepA_L1 / Y_CHILDS_HepA_L1)*100);
			}
			if(Y_CHILDS_HepA_I1 != 0){
				RE_CHILDS_HepA_I1 = df.format(((float) S_CHILDS_HepA_I1 / Y_CHILDS_HepA_I1)*100);
			}
			if(Y_CHILDS_HepA_I2 != 0){
				RE_CHILDS_HepA_I2 = df.format(((float) S_CHILDS_HepA_I2 / Y_CHILDS_HepA_I2)*100);
			}
			
			tmpMap.put("index", index);
			tmpMap.put("officeArea", officeArea);
			tmpMap.put("officeId", officeId);
			//非根子节点应种统计
			tmpMap.put("BCG_SH", Y_CHILDS_BCG);
			tmpMap.put("HEPB_AA_SH", Y_CHILDS_JSS);
			tmpMap.put("HEPB_A_SH", Y_CHILDS_HepB1);
			tmpMap.put("HEPB_B_SH", Y_CHILDS_HepB2);
			tmpMap.put("HEPB_C_SH", Y_CHILDS_HepB3);
			tmpMap.put("PV_A_SH", Y_CHILDS_PV1);
			tmpMap.put("PV_B_SH", Y_CHILDS_PV2);
			tmpMap.put("PV_C_SH", Y_CHILDS_PV3);
			tmpMap.put("PV_D_SH", Y_CHILDS_PV4);
			tmpMap.put("DTP_A_SH", Y_CHILDS_DTP1);
			tmpMap.put("DTP_B_SH", Y_CHILDS_DTP2);
			tmpMap.put("DTP_C_SH", Y_CHILDS_DTP3);
			tmpMap.put("DTP_D_SH", Y_CHILDS_DTP4);
			tmpMap.put("DT_SH", Y_CHILDS_DT1);
			tmpMap.put("MR_A_SH", Y_CHILDS_MR1);
			tmpMap.put("MR_B_SH", Y_CHILDS_MR2);
			tmpMap.put("MMR_A_SH", Y_CHILDS_MMR1);
			tmpMap.put("MMR_B_SH", Y_CHILDS_MMR2);
			tmpMap.put("MM_A_SH", Y_CHILDS_MM1);
			tmpMap.put("MM_B_SH", Y_CHILDS_MM2);
			tmpMap.put("MV_A_SH", Y_CHILDS_MV1);
			tmpMap.put("MV_B_SH", Y_CHILDS_MV2);
			tmpMap.put("MENA_A_SH", Y_CHILDS_MENA1);
			tmpMap.put("MENA_B_SH", Y_CHILDS_MENA2);
			tmpMap.put("MENAC_A_SH", Y_CHILDS_MENAC1);
			tmpMap.put("MENAC_B_SH", Y_CHILDS_MENAC2);
			tmpMap.put("JEL_A_SH", Y_CHILDS_JE_L1);
			tmpMap.put("JEL_B_SH", Y_CHILDS_JE_L2);
			tmpMap.put("JEI_A_SH", Y_CHILDS_JE_I1);
			tmpMap.put("JEI_B_SH", Y_CHILDS_JE_I2);
			tmpMap.put("JEI_C_SH", Y_CHILDS_JE_I3);
			tmpMap.put("JEI_D_SH", Y_CHILDS_JE_I4);
			tmpMap.put("HEPAL_SH", Y_CHILDS_HepA_L1);
			tmpMap.put("HEPAI_A_SH", Y_CHILDS_HepA_I1);
			tmpMap.put("HEPAI_B_SH", Y_CHILDS_HepA_I2);
			resultSHList.add(Y_CHILDS_BCG);
			resultSHList.add(Y_CHILDS_JSS);
			resultSHList.add(Y_CHILDS_HepB1);
			resultSHList.add(Y_CHILDS_HepB2);
			resultSHList.add(Y_CHILDS_HepB3);
			resultSHList.add(Y_CHILDS_PV1);
			resultSHList.add(Y_CHILDS_PV2);
			resultSHList.add(Y_CHILDS_PV3);
			resultSHList.add(Y_CHILDS_PV4);
			resultSHList.add(Y_CHILDS_DTP1);
			resultSHList.add(Y_CHILDS_DTP2);
			resultSHList.add(Y_CHILDS_DTP3);
			resultSHList.add(Y_CHILDS_DTP4);
			resultSHList.add(Y_CHILDS_DT1);
			resultSHList.add(Y_CHILDS_MR1);
			resultSHList.add(Y_CHILDS_MR2);
			resultSHList.add(Y_CHILDS_MMR1);
			resultSHList.add(Y_CHILDS_MMR2);
			resultSHList.add(Y_CHILDS_MM1);
			resultSHList.add(Y_CHILDS_MM2);
			resultSHList.add(Y_CHILDS_MV1);
			resultSHList.add(Y_CHILDS_MV2);
			resultSHList.add(Y_CHILDS_MENA1);
			resultSHList.add(Y_CHILDS_MENA2);
			resultSHList.add(Y_CHILDS_MENAC1);
			resultSHList.add(Y_CHILDS_MENAC2);
			resultSHList.add(Y_CHILDS_JE_L1);
			resultSHList.add(Y_CHILDS_JE_L2);
			resultSHList.add(Y_CHILDS_JE_I1);
			resultSHList.add(Y_CHILDS_JE_I2);
			resultSHList.add(Y_CHILDS_JE_I3);
			resultSHList.add(Y_CHILDS_JE_I4);
			resultSHList.add(Y_CHILDS_HepA_L1);
			resultSHList.add(Y_CHILDS_HepA_I1);
			resultSHList.add(Y_CHILDS_HepA_I2);
			
			//非根子节点实种统计
			tmpMap.put("BCG_RE", S_CHILDS_BCG);
			tmpMap.put("HEPB_AA_RE", S_CHILDS_JSS);
			tmpMap.put("HEPB_A_RE", S_CHILDS_HepB1);
			tmpMap.put("HEPB_B_RE", S_CHILDS_HepB2);
			tmpMap.put("HEPB_C_RE", S_CHILDS_HepB3);
			tmpMap.put("PV_A_RE", S_CHILDS_PV1);
			tmpMap.put("PV_B_RE", S_CHILDS_PV2);
			tmpMap.put("PV_C_RE", S_CHILDS_PV3);
			tmpMap.put("PV_D_RE", S_CHILDS_PV4);
			tmpMap.put("DTP_A_RE", S_CHILDS_DTP1);
			tmpMap.put("DTP_B_RE", S_CHILDS_DTP2);
			tmpMap.put("DTP_C_RE", S_CHILDS_DTP3);
			tmpMap.put("DTP_D_RE", S_CHILDS_DTP4);
			tmpMap.put("DT_RE", S_CHILDS_DT1);
			tmpMap.put("MR_A_RE", S_CHILDS_MR1);
			tmpMap.put("MR_B_RE", S_CHILDS_MR2);
			tmpMap.put("MMR_A_RE", S_CHILDS_MMR1);
			tmpMap.put("MMR_B_RE", S_CHILDS_MMR2);
			tmpMap.put("MM_A_RE", S_CHILDS_MM1);
			tmpMap.put("MM_B_RE", S_CHILDS_MM2);
			tmpMap.put("MV_A_RE", S_CHILDS_MV1);
			tmpMap.put("MV_B_RE", S_CHILDS_MV2);
			tmpMap.put("MENA_A_RE", S_CHILDS_MENA1);
			tmpMap.put("MENA_B_RE", S_CHILDS_MENA2);
			tmpMap.put("MENAC_A_RE", S_CHILDS_MENAC1);
			tmpMap.put("MENAC_B_RE", S_CHILDS_MENAC2);
			tmpMap.put("JEL_A_RE", S_CHILDS_JE_L1);
			tmpMap.put("JEL_B_RE", S_CHILDS_JE_L2);
			tmpMap.put("JEI_A_RE", S_CHILDS_JE_I1);
			tmpMap.put("JEI_B_RE", S_CHILDS_JE_I2);
			tmpMap.put("JEI_C_RE", S_CHILDS_JE_I3);
			tmpMap.put("JEI_D_RE", S_CHILDS_JE_I4);
			tmpMap.put("HEPAL_RE", S_CHILDS_HepA_L1);
			tmpMap.put("HEPAI_A_RE", S_CHILDS_HepA_I1);
			tmpMap.put("HEPAI_B_RE", S_CHILDS_HepA_I2);
			resultREList.add(S_CHILDS_BCG);
			resultREList.add(S_CHILDS_JSS);
			resultREList.add(S_CHILDS_HepB1);
			resultREList.add(S_CHILDS_HepB2);
			resultREList.add(S_CHILDS_HepB3);
			resultREList.add(S_CHILDS_PV1);
			resultREList.add(S_CHILDS_PV2);
			resultREList.add(S_CHILDS_PV3);
			resultREList.add(S_CHILDS_PV4);
			resultREList.add(S_CHILDS_DTP1);
			resultREList.add(S_CHILDS_DTP2);
			resultREList.add(S_CHILDS_DTP3);
			resultREList.add(S_CHILDS_DTP4);
			resultREList.add(S_CHILDS_DTP1);
			resultREList.add(S_CHILDS_DTP2);
			resultREList.add(S_CHILDS_DTP3);
			resultREList.add(S_CHILDS_DTP4);
			resultREList.add(S_CHILDS_DT1);
			resultREList.add(S_CHILDS_MR1);
			resultREList.add(S_CHILDS_MR2);
			resultREList.add(S_CHILDS_MMR1);
			resultREList.add(S_CHILDS_MMR2);
			resultREList.add(S_CHILDS_MM1);
			resultREList.add(S_CHILDS_MM2);
			resultREList.add(S_CHILDS_MV1);
			resultREList.add(S_CHILDS_MV2);
			resultREList.add(S_CHILDS_MENA1);
			resultREList.add(S_CHILDS_MENA2);
			resultREList.add(S_CHILDS_MENAC1);
			resultREList.add(S_CHILDS_MENAC2);
			resultREList.add(S_CHILDS_JE_L1);
			resultREList.add(S_CHILDS_JE_L2);
			resultREList.add(S_CHILDS_JE_I1);
			resultREList.add(S_CHILDS_JE_I2);
			resultREList.add(S_CHILDS_JE_I3);
			resultREList.add(S_CHILDS_JE_I4);
			resultREList.add(S_CHILDS_HepA_L1);
			resultREList.add(S_CHILDS_HepA_I1);
			resultREList.add(S_CHILDS_HepA_I2);
			
			//非根子节点接种率统计
			tmpMap.put("BCG_SR", RE_CHILDS_BCG);
			tmpMap.put("HEPB_AA_SR", RE_CHILDS_JSS);
			tmpMap.put("HEPB_A_SR", RE_CHILDS_HepB1);
			tmpMap.put("HEPB_B_SR", RE_CHILDS_HepB2);
			tmpMap.put("HEPB_C_SR", RE_CHILDS_HepB3);
			tmpMap.put("PV_A_SR", RE_CHILDS_PV1);
			tmpMap.put("PV_B_SR", RE_CHILDS_PV2);
			tmpMap.put("PV_C_SR", RE_CHILDS_PV3);
			tmpMap.put("PV_D_SR", RE_CHILDS_PV4);
			tmpMap.put("DTP_A_SR", RE_CHILDS_DTP1);
			tmpMap.put("DTP_B_SR", RE_CHILDS_DTP2);
			tmpMap.put("DTP_C_SR", RE_CHILDS_DTP3);
			tmpMap.put("DTP_D_SR", RE_CHILDS_DTP4);
			tmpMap.put("DT_SR", RE_CHILDS_DT1);
			tmpMap.put("MR_A_SR", RE_CHILDS_MR1);
			tmpMap.put("MR_B_SR", RE_CHILDS_MR2);
			tmpMap.put("MMR_A_SR", RE_CHILDS_MMR1);
			tmpMap.put("MMR_B_SR", RE_CHILDS_MMR2);
			tmpMap.put("MM_A_SR", RE_CHILDS_MM1);
			tmpMap.put("MM_B_SR", RE_CHILDS_MM2);
			tmpMap.put("MV_A_SR", RE_CHILDS_MV1);
			tmpMap.put("MV_B_SR", RE_CHILDS_MV2);
			tmpMap.put("MENA_A_SR", RE_CHILDS_MENA1);
			tmpMap.put("MENA_B_SR", RE_CHILDS_MENA2);
			tmpMap.put("MENAC_A_SR", RE_CHILDS_MENAC1);
			tmpMap.put("MENAC_B_SR", RE_CHILDS_MENAC2);
			tmpMap.put("JEL_A_SR", RE_CHILDS_JE_L1);
			tmpMap.put("JEL_B_SR", RE_CHILDS_JE_L2);
			tmpMap.put("JEI_A_SR", RE_CHILDS_JE_I1);
			tmpMap.put("JEI_B_SR", RE_CHILDS_JE_I2);
			tmpMap.put("JEI_C_SR", RE_CHILDS_JE_I3);
			tmpMap.put("JEI_D_SR", RE_CHILDS_JE_I4);
			tmpMap.put("HEPAL_SR", RE_CHILDS_HepA_L1);
			tmpMap.put("HEPAI_A_SR", RE_CHILDS_HepA_I1);
			tmpMap.put("HEPAI_B_SR", RE_CHILDS_HepA_I2);
			resultSRList.add(RE_CHILDS_BCG);
			resultSRList.add(RE_CHILDS_JSS);
			resultSRList.add(RE_CHILDS_HepB1);
			resultSRList.add(RE_CHILDS_HepB2);
			resultSRList.add(RE_CHILDS_HepB3);
			resultSRList.add(RE_CHILDS_PV1);
			resultSRList.add(RE_CHILDS_PV2);
			resultSRList.add(RE_CHILDS_PV3);
			resultSRList.add(RE_CHILDS_PV4);
			resultSRList.add(RE_CHILDS_DTP1);
			resultSRList.add(RE_CHILDS_DTP2);
			resultSRList.add(RE_CHILDS_DTP3);
			resultSRList.add(RE_CHILDS_DTP4);
			resultSRList.add(RE_CHILDS_DT1);
			resultSRList.add(RE_CHILDS_MR1);
			resultSRList.add(RE_CHILDS_MR2);
			resultSRList.add(RE_CHILDS_MMR1);
			resultSRList.add(RE_CHILDS_MMR2);
			resultSRList.add(RE_CHILDS_MM1);
			resultSRList.add(RE_CHILDS_MM2);
			resultSRList.add(RE_CHILDS_MV1);
			resultSRList.add(RE_CHILDS_MV2);
			resultSRList.add(RE_CHILDS_MENA1);
			resultSRList.add(RE_CHILDS_MENA2);
			resultSRList.add(RE_CHILDS_MENAC1);
			resultSRList.add(RE_CHILDS_MENAC2);
			resultSRList.add(RE_CHILDS_JE_L1);
			resultSRList.add(RE_CHILDS_JE_L2);
			resultSRList.add(RE_CHILDS_JE_I1);
			resultSRList.add(RE_CHILDS_JE_I2);
			resultSRList.add(RE_CHILDS_JE_I3);
			resultSRList.add(RE_CHILDS_JE_I4);
			resultSRList.add(RE_CHILDS_HepA_L1);
			resultSRList.add(RE_CHILDS_HepA_I1);
			resultSRList.add(RE_CHILDS_HepA_I2);
			
			jsonList.add(tmpMap);
			resultList.add(tmpMap);
			String tmpStr = StringUtils.substring(JsonMapper.toJsonString(jsonList), 1, JsonMapper.toJsonString(jsonList).length()-1);
			returnStr.append(tmpStr+",");
			
			//恢复初始值,为当前节点的下一个节点数据统计做准备
			Y_CHILDS_BCG = 0;
			Y_CHILDS_JSS = 0;
			Y_CHILDS_HepB1 = 0;
			Y_CHILDS_HepB2 = 0;
			Y_CHILDS_HepB3 = 0;
			Y_CHILDS_PV1 = 0;
			Y_CHILDS_PV2 = 0;
			Y_CHILDS_PV3 = 0;
			Y_CHILDS_PV4 = 0;
			Y_CHILDS_DTP1 = 0;
			Y_CHILDS_DTP2 = 0;
			Y_CHILDS_DTP3 = 0;
			Y_CHILDS_DTP4 = 0;
			Y_CHILDS_DT1 = 0;
			Y_CHILDS_MR1 = 0;
            Y_CHILDS_MR2 = 0;
            Y_CHILDS_MMR1 = 0;
            Y_CHILDS_MMR2 = 0;
            Y_CHILDS_MM1 = 0;
            Y_CHILDS_MM2 = 0;
            Y_CHILDS_MV1 = 0;
            Y_CHILDS_MV2 = 0;
            Y_CHILDS_MENA1 = 0;
            Y_CHILDS_MENA2 = 0;
            Y_CHILDS_MENAC1 = 0;
            Y_CHILDS_MENAC2 = 0;
            Y_CHILDS_JE_L1 = 0;
            Y_CHILDS_JE_L2 = 0;
            Y_CHILDS_JE_I1 = 0;
            Y_CHILDS_JE_I2 = 0;
            Y_CHILDS_JE_I3 = 0;
            Y_CHILDS_JE_I4 = 0;
            Y_CHILDS_HepA_L1 = 0;
            Y_CHILDS_HepA_I1 = 0;
            Y_CHILDS_HepA_I2 = 0;
            S_CHILDS_BCG = 0;
            S_CHILDS_JSS = 0;
            S_CHILDS_HepB1 = 0;
            S_CHILDS_HepB2 = 0;
            S_CHILDS_HepB3 = 0;
            S_CHILDS_PV1 = 0;
            S_CHILDS_PV2 = 0;
            S_CHILDS_PV3 = 0;
            S_CHILDS_PV4 = 0;
            S_CHILDS_DTP1 = 0;
            S_CHILDS_DTP2 = 0;
            S_CHILDS_DTP3 = 0;
            S_CHILDS_DTP4 = 0;
            S_CHILDS_DT1 = 0;
            S_CHILDS_MR1 = 0;
            S_CHILDS_MR2 = 0;
            S_CHILDS_MMR1 = 0;
            S_CHILDS_MMR2 = 0;
            S_CHILDS_MMR1 = 0;
            S_CHILDS_MMR2 = 0;
            S_CHILDS_MV1 = 0;
            S_CHILDS_MV2 = 0;
            S_CHILDS_MENA1 = 0;
            S_CHILDS_MENA2 = 0;
            S_CHILDS_MENAC1 = 0;
            S_CHILDS_MENAC2 = 0;
            S_CHILDS_JE_L1 = 0;
            S_CHILDS_JE_L2 = 0;
            S_CHILDS_JE_I1 = 0;
            S_CHILDS_JE_I2 = 0;
            S_CHILDS_JE_I3 = 0;
            S_CHILDS_JE_I4 = 0;
            S_CHILDS_HepA_L1 = 0;
            S_CHILDS_HepA_I1 = 0;
            S_CHILDS_HepA_I2 = 0;
            RE_CHILDS_BCG = "0";
            RE_CHILDS_JSS = "0";
            RE_CHILDS_HepB1 = "0";
            RE_CHILDS_HepB2 = "0";
            RE_CHILDS_HepB3 = "0";
            RE_CHILDS_PV1 = "0";
            RE_CHILDS_PV2 = "0";
            RE_CHILDS_PV3 = "0";
            RE_CHILDS_PV4 = "0";
            RE_CHILDS_DTP1 = "0";
            RE_CHILDS_DTP2 = "0";
            RE_CHILDS_DTP3 = "0";
            RE_CHILDS_DTP4 = "0";
            RE_CHILDS_DT1 = "0";
            RE_CHILDS_MR1 = "0";
            RE_CHILDS_MR2 = "0";
            RE_CHILDS_MMR1 = "0";
            RE_CHILDS_MMR2 = "0";
            RE_CHILDS_MM1 = "0";
            RE_CHILDS_MM2 = "0";
            RE_CHILDS_MV1 = "0";
            RE_CHILDS_MV2 = "0";
            RE_CHILDS_MENA1 = "0";
            RE_CHILDS_MENA2 = "0";
            RE_CHILDS_MENAC1 = "0";
            RE_CHILDS_MENAC2 = "0";
            RE_CHILDS_JE_L1 = "0";
            RE_CHILDS_JE_L2 = "0";
            RE_CHILDS_JE_I1 = "0";
            RE_CHILDS_JE_I2 = "0";
            RE_CHILDS_JE_I3 = "0";
            RE_CHILDS_JE_I4 = "0";
            RE_CHILDS_HepA_L1 = "0";
            RE_CHILDS_HepA_I1 = "0";
            RE_CHILDS_HepA_I2 = "0";
		}
		StringBuffer tmpSb = new StringBuffer(StringUtils.substring(returnStr.toString(), 0, returnStr.toString().length()-1));
		resultMap.put("resultString", tmpSb.append("]").toString());
		resultMap.put("resultREList", resultREList);
		resultMap.put("resultSHList", resultSHList);
		resultMap.put("resultSRList", resultSRList);
		resultMap.put("resultList", resultList);
		return resultMap;
		
	}
	
	// ------------------------------------------------------------------------------------------
	// -------------------------------常规免疫6-1结束-------------------------------------------//
	// ------------------------------------------------------------------------------------------
	
	
	
	
	// ------------------------------------------------------------------------------------------
	// -------------------------------国家常规免疫6-1开始---------------------------------------//
	// ------------------------------------------------------------------------------------------
	
	/**
	 * 处理国家免疫规划疫苗常规接种情况报表(表6-1)数据
	 * @author Jack
	 * @date 2017年10月19日 上午9:36:07
	 * @description 
	 * @param map
	 * @return
	 *
	 */
	public List<List<HashMap<String, String>>> manageNationalIPVRoutineVaccReport6_1(HashMap<String, String> map) {
		List<HashMap<String, String>> datalist = null;
		if(!map.get("reside").equals("0")){
			datalist = nationalRoutineVaccWithReside6_1(map.get("reside"), map.get("startTime"), map.get("endTime"));
		}else{
			datalist = nationalRoutineVaccNoReside6_1(map.get("startTime"), map.get("endTime"));
		}
		List<List<HashMap<String, String>>> returnlist = new ArrayList<List<HashMap<String, String>>>();
		List<HashMap<String, String>> tempList = new ArrayList<HashMap<String, String>>();
		if(datalist !=null && datalist.size()>0){
			for(int i=1;(i<=datalist.size()/20);i++){
				tempList.addAll(datalist.subList((i-1)*20, i*20));
				returnlist.add(tempList);
				tempList = new ArrayList<HashMap<String, String>>();
			}
			tempList.addAll(datalist.subList(datalist.size()-datalist.size()%20, datalist.size()));
			returnlist.add(tempList);
			tempList = new ArrayList<HashMap<String, String>>();
		}else{
			return new ArrayList<List<HashMap<String, String>>>();
		}
		return returnlist;
	}
	
	/**
	 * 国家免疫规划疫苗常规接种情况报表(表6-1)
	 * @author Jack
	 * @date 2017年10月19日 上午9:45:29
	 * @description 
	 * @param map
	 * @return
	 *
	 */
	private List<HashMap<String, String>> nationalRoutineVaccWithReside6_1(String reside, String startTime, String endTime) {
		return dao.nationalRoutineVaccWithReside6_1(reside, startTime, endTime);
	}
	
	private List<HashMap<String, String>> nationalRoutineVaccNoReside6_1(String startTime, String endTime) {
		return dao.nationalRoutineVaccNoReside6_1( startTime, endTime);
	}
	
	
	
	
	// ------------------------------------------------------------------------------------------
	// -------------------------------国家常规免疫6-1结束---------------------------------------//
	// ------------------------------------------------------------------------------------------
	
	
	
	
	// ------------------------------------------------------------------------------------------
	// -------------------------------Util Methods Start---------------------------------------//
	// ------------------------------------------------------------------------------------------
    /**
     * 设置基本属性
     * @author Jack
     * @date 2017年11月6日 上午10:02:10
     * @description 
     *
     */
    public void setInfo(ExportChildhelp exportChildhelp, Model model ,String live){
    	if(StringUtils.isNotBlank(exportChildhelp.getYearStr()) && StringUtils.isNotBlank(exportChildhelp.getStartMonth()) && StringUtils.isNotBlank(exportChildhelp.getEndMonth())){
			//处理和绑定时间
			exportChildhelp.setStartTime(TimeUtils.getFirstDayOfMonth(Integer.valueOf(exportChildhelp.getYearStr()),Integer.parseInt(exportChildhelp.getStartMonth())-1)+" "+"00:00:00");
			exportChildhelp.setEndTime(TimeUtils.getLastDayOfMonth(Integer.valueOf(exportChildhelp.getYearStr()),Integer.parseInt(exportChildhelp.getEndMonth())-1)+" "+"23:59:59");
			model.addAttribute("live",live);
		}else{
			//默认设置 开始月份:当年1月,结束月份:当月的上一个月份
			Integer nowMonth = Integer.parseInt(DateUtils.getMonth());
			exportChildhelp.setStartTime((Integer.valueOf(DateUtils.formatDate(new Date(), "yyyy")))+"-"+(DateUtils.formatDate(new Date(), "MM"))+"-01"+" "+"00:00:00");
			exportChildhelp.setEndTime(TimeUtils.getLastDayOfMonth(Integer.valueOf(DateUtils.formatDate(new Date(), "yyyy")), Integer.valueOf(DateUtils.formatDate(new Date(), "MM"))-1)+" "+"23:59:59");
			exportChildhelp.setYearStr(DateUtils.formatDate(new Date(), "yyyy"));
			exportChildhelp.setStartMonth(nowMonth-2 + "");
			exportChildhelp.setEndMonth(nowMonth-1 + "");
			model.addAttribute("live", "0");
		}
    	return;
    }
    
    // ------------------------------------------------------------------------------------------
 	// ---------------------------------Util Methods End---------------------------------------//
 	// ------------------------------------------------------------------------------------------
    
    
    //----------------------------------计算echarts数据开始-------------------------------------//
    /**
     * 计算得出echarts数据格式
     * @author Jack
     * @date 2017年11月16日 下午8:53:46
     * @description 
     * 数据格式示例：
     * model.addAttribute("min1",0);
     * model.addAttribute("min2",0);
     * model.addAttribute("min3",0);
     * model.addAttribute("max1",250);
     * model.addAttribute("max2",250);
     * model.addAttribute("max3",250);
     * model.addAttribute("xAxisData","['1月','2月','3月','4月','5月','6月','7月','8月','9月','10月','11月','12月']");
     * model.addAttribute("seriesData1","[2.0, 4.9, 7.0, 23.2, 25.6, 76.7, 135.6, 162.2, 32.6, 20.0, 6.4, 3.3]");
     * model.addAttribute("seriesData2","[2.6, 5.9, 9.0, 26.4, 28.7, 70.7, 175.6, 182.2, 48.7, 18.8, 6.0, 2.3]");
     * model.addAttribute("seriesData3","[2.0, 2.2, 3.3, 4.5, 6.3, 10.2, 20.3, 23.4, 23.0, 16.5, 12.0, 6.2]");
     * @param resultStr 传入的json String
     * @return
     */
    @SuppressWarnings({"unchecked" })
    public HashMap<String, Object> getEchartsData(HashMap<String, Object> dataMap){
    	HashMap<String, Object> resultMap = new HashMap<String, Object>();
    	List<HashMap<String, Object>> resultList = (List<HashMap<String, Object>>) dataMap.get("resultList");
    	
		List<Integer> resultREList = (List<Integer>) dataMap.get("resultREList");
		List<Integer> resultSHList = (List<Integer>) dataMap.get("resultSHList");
		List<String> resultSRList = (List<String>) dataMap.get("resultSRList");
    	Integer maxRE = CollectionUtils.getMaxDataOfInteger(resultREList);
		Integer maxSH = CollectionUtils.getMaxDataOfInteger(resultSHList);
		Float maxSR = CollectionUtils.getMaxDataOfFloat(resultSRList);
		maxRE = (int) (maxRE + maxRE*0.1);
		maxSH = (int) (maxSH + maxSH*0.1);
		
		LinkedHashMap<String, Object> shMap = new LinkedHashMap<String, Object>();
		LinkedHashMap<String, Object> reMap = new LinkedHashMap<String, Object>();
		LinkedHashMap<String, Object> srMap = new LinkedHashMap<String, Object>();
		
		TreeSet<String> vaccinateTreeSet = getVaccinateSet(resultList);
		
		String nameStr = new String();
		
		HashMap<String, HashMap<String, String>> strMap = new HashMap<String, HashMap<String, String>>();
		
		for(HashMap<String, Object> map : resultList){
			StringBuffer stringBufferSH = new StringBuffer("[");
			StringBuffer stringBufferRE = new StringBuffer("[");
			StringBuffer stringBufferSR = new StringBuffer("[");
			StringBuffer sbVaccinateName = new StringBuffer("[");
			String shStr = new String("");
			String reStr = new String("");
			String srStr = new String("");
			for(String str : vaccinateTreeSet){
				sbVaccinateName.append("'" + str + "',");
				for(String key : map.keySet()){
					String tmp = key.substring(key.length()-3, key.length());
					if(key.replace(tmp, "").equals(str)){
						if(tmp.equals("_SH")){
							shMap.put(key, map.get(key));
							stringBufferSH.append("'" + map.get(key) + "',");
						}else if(tmp.equals("_RE")){
							reMap.put(key, map.get(key));
							stringBufferRE.append("'" + map.get(key) + "',");
						}else if(tmp.equals("_SR")){
							srMap.put(key, map.get(key));
							stringBufferSR.append("'" + map.get(key) + "',");
						}else{
							continue;
						}
					}
				}
			}
			nameStr = sbVaccinateName.substring(0, sbVaccinateName.length()-1).toString() + "]";
			HashMap<String, String> tmpMap = new HashMap<String, String>();
			shStr = stringBufferSH.substring(0, stringBufferSH.length()-1).toString() + "]";
			reStr = stringBufferRE.substring(0, stringBufferRE.length()-1).toString() + "]";
			srStr = stringBufferSR.substring(0, stringBufferSR.length()-1).toString() + "]";
			tmpMap.put("shStr", shStr);
			tmpMap.put("reStr", reStr);
			tmpMap.put("srStr", srStr);
			strMap.put((String) map.get("officeArea"), tmpMap);
		}
		
		StringBuffer seriesSb = new StringBuffer("[");
		for(String outkey : strMap.keySet()){
			HashMap<String, String> innerMap = strMap.get(outkey);
			StringBuffer tmpSb = new StringBuffer();
			for(String innerkey : innerMap.keySet()){
				if(innerkey.equals("shStr")){
					tmpSb.append("{ name:'" + outkey + "应种数', type: 'bar', yAxisIndex: 0, data: "  + innerMap.get(innerkey) + "},");
				}else if(innerkey.equals("reStr")){
					tmpSb.append("{ name:'" + outkey + "实种数', type: 'bar', yAxisIndex: 1, data: " + innerMap.get(innerkey) + "},");
				}else if(innerkey.equals("srStr")){
					tmpSb.append("{ name:'" + outkey + "接种率', type: 'line', yAxisIndex: 2, data: " + innerMap.get(innerkey) + "},"); 
				}
			}
			seriesSb.append(tmpSb);
		}
		String seriesStr = seriesSb.toString().substring(0, seriesSb.length()-1) + "]";
		
    	resultMap.put("minRE",0);  
    	resultMap.put("minSH",0);  
    	resultMap.put("minSR",0);  
    	resultMap.put("maxRE",maxRE);
    	resultMap.put("maxSH",maxSH);
    	resultMap.put("maxSR",maxSR);
    	resultMap.put("xAxisData", nameStr);       
    	resultMap.put("seriesStr", seriesStr);
    	return resultMap;
    }
    
    //----------------------------------计算echarts数据结束-------------------------------------//
    
    
    //------------------------------vaccinate 数据处理Utils开始---------------------------------//
    public TreeSet<String> getVaccinateSet(List<HashMap<String, Object>> list){
    	TreeSet<String> vaccinateNameSet = new TreeSet<String>();
    	for(HashMap<String, Object> map : list){
    		for(String key : map.keySet()){
    			if(!key.equals("officeId") && !key.equals("officeArea") && !key.equals("index")){
    				vaccinateNameSet.add(key.replace(key.substring(key.length()-3, key.length()), ""));
    			}
    		}
    	}
    	
    	return vaccinateNameSet;
    } 
    //------------------------------vaccinate 数据处理Utils结束---------------------------------//
    
    
    /**
     * 查询互联网版本社区信息
     * @author Jack
     * @date 2018年3月1日 上午2:12:12
     * @description 
     * @return
     *
     */
	public List<HashMap<String, String>> selectCommunityListNetVersion() {
		return dao.selectCommunityListNetVersion();
	}
    
	/**
	 * 根据传入的年月、localCode判断该条件下生成的数据总条数根据传入的年月、localCode判断该条件下生成的数据总条数
	 * @author Jack
	 * @date 2018年2月9日 下午1:19:54
	 * @description 
	 * @param yearMonth 年月字符串
	 * @param localCode 本地编码
	 * @return
	 */
	public int countDataByMonthAndLocalCode(String yearMonth, String localCode){
		return dao.countDataByMonthAndLocalCode(yearMonth, localCode);
	}
	
}
